First class file I/O

Pil, Marco

doi:10.1007/3-540-63237-9_28

Cited by 7 publications

(2 citation statements)

References 4 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…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).…”

Section: Introductionmentioning

confidence: 99%

Embedding polymorphic dynamic typing

Noort

Swierstra

Achten

et al. 2011

Proceedings of the Seventh ACM SIGPLAN Workshop on Generic Programming

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

Section: Introductionmentioning

confidence: 99%

Embedding polymorphic dynamic typing

Noort

Swierstra

Achten

et al. 2011

Proceedings of the Seventh ACM SIGPLAN Workshop on Generic Programming

View full text Add to dashboard Cite

show abstract

“…Haskell has minimal support for dynamic typing, it only sup ports monomorphism (Baars and Swierstra, 2002;Cheney and Hinze, 2002). Clean, on the other hand, has a rich and mature dynamic typing system; it adopted ML's support for monomor phism (Abadi et al, 1991;Pil, 1997) and parametric polymor phism (Abadietal., 1994;Leroy andMauny, 1993). Additionally, it includes the notion of type dependencies (Pil, 1999).…”

Section: Introductionmentioning

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

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

Lazy Dynamic Input/Output in the Lazy Functional Language Clean

Vervoort¹,

Plasmeijer²

2003

Implementation of Functional Languages

View full text Add to dashboard Cite

First class file I/O

Cited by 7 publications

References 4 publications

Embedding polymorphic dynamic typing

Embedding polymorphic dynamic typing

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

Lazy Dynamic Input/Output in the Lazy Functional Language Clean

Contact Info

Product

Resources

About