A Functional Shell That Operates on Typed and Compiled Applications

Plasmeijer, Rinus; Weelden, Arjen van

doi:10.1007/11546382_6

Cited by 3 publications

(2 citation statements)

References 10 publications

(10 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…An extensive overview of the interaction between ad-hoc polymor phism and dynamic typing in a statically typed functional language has not been described earlier. However, bringing the worlds of adhoc polymorphism and dynamic typing has been recognised before by Plasmeijer and van Weelden (2005). An interactive shell is de scribed to interpret user-provided values using the dynamic typing system.…”

Section: Discussionmentioning

confidence: 99%

Ad-hoc polymorphism and dynamic typing in a statically typed functional language

Noort

Achten

Plasmeijer

2010

Proceedings of the 6th ACM SIGPLAN Workshop on Generic Programming

Self Cite

View full text Add to dashboard Cite

Static typing in functional programming languages such as Clean, Haskell, and ML is highly beneficial: it prevents erroneous be haviour at run time and provides opportunities for optimisations. However, dynamic typing is just as important as sometimes types are not known until run time. Examples are exchanging values be tween applications by deserialisation from disk, input provided by a user, or obtaining values via a network connection. Ideally, a static typing system works in close harmony with an orthogonal dynamic typing system; not discriminating between statically and dynamically typed values. In contrast to Haskell's minimal sup port for dynamic typing, Clean has an extensive dynamic typing; it adopted ML's support for monomorphism and parametric polymor phism and added the notion of type dependencies. Unfortunately, ad-hoc polymorphism has been left out of the equation over the years. While both ad-hoc polymorphism and dynamic typing have been studied in-depth earlier, their interaction in a statically typed functional language has not been studied before. In this paper we explore the design space of their interactions.

show abstract

Section: Discussionmentioning

confidence: 99%

Ad-hoc polymorphism and dynamic typing in a statically typed functional language

Noort

Achten

Plasmeijer

2010

Proceedings of the 6th ACM SIGPLAN Workshop on Generic Programming

Self Cite

View full text Add to dashboard Cite

show abstract

“…Then, a value is unwrapped using the library function fromDyn which performs a cast, where the required type is specified by the context in which it is unwrapped: inc :: Maybe (Int → Int) inc = fromDyn incDyn Clean, on the other hand, has a more rich and mature dynamic typing system that is built in; it adopted ML's support for monomorphism (Abadi et al, 1991;Pil, 1997) and polymorphism (Abadi et al, 1994;Leroy and Mauny, 1993). Having such an extensive dynamic typing system does not only improve orthogonality with the static typing system (Van Noort et al, 2010), but also has important applications (Plasmeijer and Van Weelden, 2005;Plasmeijer et al, 2011). In Clean, we wrap a value, for example the polymorphic identity function, in a dynamic by using the corresponding keyword:…”

Section: Introductionmentioning

confidence: 99%

Embedding polymorphic dynamic typing

Noort

Swierstra

Achten

et al. 2011

Proceedings of the Seventh ACM SIGPLAN Workshop on Generic Programming

Self Cite

View full text Add to dashboard Cite

Dynamic typing in a statically typed functional language allows us to defer type unification until run time. This is typically useful when interacting with the 'outside' world where the type of values involved may not be known statically. Haskell has minimal support for dynamic typing, it only supports monomorphism. Clean, on the other hand, has a more rich and mature dynamic typing system where polymorphism is supported as well. An interesting difference is that Haskell offers monomorphic dynamic typing via a library, while Clean offers polymorphic dynamic typing via builtin language support. In the Clean approach there is a great deal of freedom in the implementation in the compiler since the dynamic typing system is defined on abstract syntax trees, whereas the Haskell approach does not need to extend the core language and hence reduces the complexity of the language and compiler. In this paper we investigate what it takes for a functional language to embed polymorphic dynamic typing. We explore an embedding in Haskell using generalised algebraic datatypes and argue that a universe for the representation of types needs to separated from its interpretation as a type. We motivate the need for a dependentlytyped functional language like Agda and perform the embedding using structural equality on type representations. Finally, we extend this approach with an instance-of algorithm and define a framework for the corresponding cast function.

show abstract

A Foreign Language Interface from ML to Shell

Ueno

Ohori

2016

New Gener. Comput.

View full text Add to dashboard Cite

A Functional Shell That Operates on Typed and Compiled Applications

Cited by 3 publications

References 10 publications

Ad-hoc polymorphism and dynamic typing in a statically typed functional language

Ad-hoc polymorphism and dynamic typing in a statically typed functional language

Embedding polymorphic dynamic typing

A Foreign Language Interface from ML to Shell

Contact Info

Product

Resources

About