[racket-users] Second Call for Papers: PACMPL issue ICFP 2018

['Lindsey Kuper' via users-redirect]

PACMPL Volume 2, Issue ICFP 2018
Call for Papers 

accepted papers to be invited for presentation at
 The 23rd ACM SIGPLAN International Conference on Functional Programming 
St. Louis, Missouri, USA 
   http://icfp18.sigplan.org/

### Important dates 

Submissions due:16 March 2018 (Friday) Anywhere on Earth 
https://icfp18.hotcrp.com 
Author response:2 May (Wednesday) - 4 May (Friday) 14:00 UTC
Notification:   18 May (Friday)
Final copy due: 22 June (Friday)
Conference: 24 September (Monday) - 26 September (Wednesday)

### About PACMPL

Proceedings of the ACM on Programming Languages (PACMPL 
) is a Gold Open Access journal publishing research on 
all aspects of programming languages, from design to implementation and from 
mathematical formalisms to empirical studies. Each issue of the journal is 
devoted to a particular subject area within programming languages and will be 
announced through publicized Calls for Papers, like this one.

### Scope

[PACMPL](https://pacmpl.acm.org/) issue ICFP 2018 seeks original papers on the 
art and science of functional programming. Submissions are invited on all 
topics from principles to practice, from foundations to features, and from 
abstraction to application. The scope includes all languages that encourage 
functional programming, including both purely applicative and imperative 
languages, as well as languages with objects, concurrency, or parallelism. 
Topics of interest include (but are not limited to):

  * *Language Design*: concurrency, parallelism, and distribution; modules; 
components and composition; metaprogramming; type systems; interoperability; 
domain-specific languages; and relations to imperative, object-oriented, or 
logic programming.

  * *Implementation*: abstract machines; virtual machines; interpretation; 
compilation; compile-time and run-time optimization; garbage collection and 
memory management; multi-threading; exploiting parallel hardware; interfaces to 
foreign functions, services, components, or low-level machine resources.

  * *Software-Development Techniques*: algorithms and data structures; design 
patterns; specification; verification; validation; proof assistants; debugging; 
testing; tracing; profiling.

  * *Foundations*: formal semantics; lambda calculus; rewriting; type theory; 
monads; continuations; control; state; effects; program verification; dependent 
types.

  * *Analysis and Transformation*: control-flow; data-flow; abstract 
interpretation; partial evaluation; program calculation.

  * *Applications*: symbolic computing; formal-methods tools; artificial 
intelligence; systems programming; distributed-systems and web programming; 
hardware design; databases; XML processing; scientific and numerical computing; 
graphical user interfaces; multimedia and 3D graphics programming; scripting; 
system administration; security.

  * *Education*: teaching introductory programming; parallel programming; 
mathematical proof; algebra.

Submissions will be evaluated according to their relevance, correctness, 
significance, originality, and clarity. Each submission should explain its 
contributions in both general and technical terms, clearly identifying what has 
been accomplished, explaining why it is significant, and comparing it with 
previous work. The technical content should be accessible to a broad audience.

PACMPL issue ICFP 2018 also welcomes submissions in two separate categories 
 Functional Pearls and Experience Reports  that must be marked as 
such at the time of submission and that need not report original research 
results.  Detailed guidelines on both categories are given at the end of this 
call.

Please contact the principal editor if you have questions or are concerned 
about the appropriateness of a topic.

### Preparation of submissions

**Deadline**: The deadline for submissions is Friday, March 16, 2018, Anywhere 
on Earth ().  This deadline 
will be strictly enforced.

**Formatting**: Submissions must be in PDF format, printable in black and white 
on US Letter sized paper, and interpretable by common PDF tools. All 
submissions must adhere to the "ACM Small" template that is available (in both 
LaTeX and Word formats) from 
.  For authors using 
LaTeX, a lighter-weight package, including only the essential files, is 
available from .

There is a limit of 27 pages for a full paper or 14 pages for an Experience 
Report; in either case, the bibliography will not be counted against these 
limits. These page limits have been chosen to allow essentially the same amount 
of content with the new single-column format as was possible with the 
two-column format used in past ICFP 

Re: [racket-users] Defining algebraic data types?

[Sam Tobin-Hochstadt]

A few answers:

1. Use struct subtyping to give a type that includes both kinds:
(struct dual ())
(struct quaternion dual (scalar vector))
(struct dual-quaternon dual (real dual))

2. Use a library that supports algebraic data types, such as
https://pkgs.racket-lang.org/package/datatype

Sam

On Sun, Feb 4, 2018 at 9:16 AM, HiPhish  wrote:
> Hell Racketeers,
>
> I am trying to write an implementation of the mathematical concept of dual
> quaternions in Racket. Dual quaternions are an algebraic type and there are
> several equally valid way to look at them.
>
> Let me give some background first. A dual number (a + bε) is similar to a
> complex number (a + bi), except that the square of ε is 0 instead of -1. A
> quaternion (a + bi + cj + dk) is like a complex number, except that it has
> three complex units which all square to -1. A dual quaternion is either a
> dual
> number where both components are quaternions, or a quaternion where all four
> components are dual numbers. There are also "subtypes" of dual quaternoins:
> a
> dual scalar is a dual quaternions where the vector parts of the two
> quaternions
> are zero, and a dual vector (not to be confused with the dual vectors from
> linear algebra) is a dual quaternions where the scalar part of both
> quaternions
> is zero. Unlike the subtypes in OOP these algebraic subtypes have *less*
> information than their parent (kind of like a square is a rectangle defined
> by
> only one length instead of two). (If you want to get really down to it, dual
> quaternions are elements of the Clifford algebra Cl^+(0, 3, 1).)
>
> So my question is: what would be the best way of defining such algebraic
> types?
> At first I wanted to create a struct:
>
> (define vector (i j k))
> (struct quaternion (scalar vector))
> (struct dual-quaternon (real dual))
>
> But this limits me to a "dual number where both components are quaternions"
> view of the type. It also means that each dual scalar has be a sort of
> mishapped dual quaternion.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to racket-users+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Defining algebraic data types?

[HiPhish]

Hell Racketeers,

I am trying to write an implementation of the mathematical concept of dual
quaternions in Racket. Dual quaternions are an algebraic type and there are
several equally valid way to look at them.

Let me give some background first. A dual number (a + bε) is similar to a
complex number (a + bi), except that the square of ε is 0 instead of -1. A
quaternion (a + bi + cj + dk) is like a complex number, except that it has
three complex units which all square to -1. A dual quaternion is either a 
dual
number where both components are quaternions, or a quaternion where all four
components are dual numbers. There are also "subtypes" of dual quaternoins: 
a
dual scalar is a dual quaternions where the vector parts of the two 
quaternions
are zero, and a dual vector (not to be confused with the dual vectors from
linear algebra) is a dual quaternions where the scalar part of both 
quaternions
is zero. Unlike the subtypes in OOP these algebraic subtypes have *less*
information than their parent (kind of like a square is a rectangle defined 
by
only one length instead of two). (If you want to get really down to it, dual
quaternions are elements of the Clifford algebra Cl^+(0, 3, 1).)

So my question is: what would be the best way of defining such algebraic 
types?
At first I wanted to create a struct:

(define vector (i j k))
(struct quaternion (scalar vector))
(struct dual-quaternon (real dual))

But this limits me to a "dual number where both components are quaternions"
view of the type. It also means that each dual scalar has be a sort of
mishapped dual quaternion.

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.