sintrastes / hafly Goto Github PK

View Code? Open in Web Editor NEW

3.0 2.0 0.0 1.18 MB

Dynamic embeddable scripting language in Haskell.

Home Page: https://sintrastes.github.io/hafly

License: GNU Affero General Public License v3.0

Haskell 98.07% Nix 1.93%

functional-programming scripting dynamically-typed embeddable-scripting-language haskell

hafly's Introduction

About me

Welcome to my github profile!

I have a wide variety of interests in sofrware development, from functional programming and type theory, formal methods, logic programming, security, GIS, and game development, to UI/UX development. So if you see something that interests you on one of my personal projects, feel free to reach out. Pull requests welcome.

🗨️ I use he/him pronouns.
📫 How to reach me: [email protected]
✏️ I write a blog about math and programming sometimes.
📚 My academic interests also include linugistics, and microtonal music theory.
💡 Ask me about graded categories.
🌳 When I'm not working on cool software projects, I like cooking, music, playing video games, and exploring the outdoors.

What's in a name?

sintrastes: "sin trastes" -- Spanish for "without frets" or fretless

My Projects

Programming Languages / DSLs

Hafly (WIP): A simple and flexible dynamically typed scripting langauge for embedding into Haskell projects.
Meriv (WIP): A statically typed functional-logic language for knowledge representation.
idr-pure-prolog: An embedded domain specific for logic programming in Idris.
STLK: Serializable and extensible simply-typed lamda calculus EDSL-building framework in Kotlin.

UI/UX Design

Iodine: Functional UI toolkit built on top of Jetpack Compose.

Music

Xen Fret: A web app for microtonal guitarists.
Xen Toolbox: Utility library in Haskell for xenharmonic theory and composition.

Linguistics / NLP

Montague: Experimental library and DSL for parsing natural language into structured from using a combination of syntactic and semantic types.
hs-nlp: Collection of experiments implementing different forms of natural language processing in Haskell.

GIS

MapAlgebra.jl: High-level declarative GIS processing library for Julia.

TAK

partech-metadata-utils: Utilities for ATAK designed to develop type-safe interfaces for ATAK core's metadata API.
atak-flix-dev: Experiment in building an ATAK plugin using the Flix programming language.

Utilities

Kinetix: A small Kotlin DSL for incremental computations.
monad-tree: A small Haskell library for a tree monad for nondeterministic computations allowing for different evaluation strategies.
buildable-kt: A Kotlin compiler plugin automatically generating a "partial" version of a data class, and some appropriate lenses.

Misc

awesome
- My personal awesome list on a variety of things I find interesting: software engineering, mathematics, urbanism.
FlixRP
- Implementation of a functional reactive programming framework in the Flix programming language.

Some fun stats

hafly's People

Contributors

Stargazers

Watchers

hafly's Issues

Allow for user-defined multiple dispatch

Currently multiple dispatch only works on library-defined functions.

I believe one reason for this is that the user currently has no way of being able to specify type signatures.

We should probably make our type signatures mirror that of Haskell's.

Implement reactive polymorphism.

Add list literals

Implement the full monadic bind syntax.

Implement UI example.

Add github CI actions

Implement record accessors.

We'll need some way to disambiguate these from function calls, maybe something like:

For an expression x.y:

If x is a record, first check to see if it has any fields y. If so, use y as a record accessor for that field.
Otherwise, check to see if there is a function y that could act on x.

Add a type function to the standard library.

Implement dynamic dispatch.

Allow for `Dynamic`s to be displayed properly.

Currently, we have:

> [1,2,3,4.2]
[<<Int>>,<<Int>>,<<Int>>,<<Double>>]

whereas it would be nice if we had:

> [1, 2, 3, 4.2]
[1, 2, 3, 4.2]

Maybe the best approach for this would be to have the interpreter see if there is a show instance for each element of the list, and try to display it that way -- otherwise, falling-back to just displaying the type?

Refactor to use a final tagless interpreter approach for the AST.

Recursive definitions don't work for monadic expressions

Implement some higher-order functions.

(.) application has issues with higher-order functions

e.x. [1, 2, 3].map \x -> x + 2

The reason for this is likely that . is not defined to use flexible application.

Implement monadic polymorphism for "map"

Make InterpreterContext a monoid

Implement optional semicolons in parser

Fix higher-order functions taking multi-argument functions as input.

Currently, examples such as foldr (\x y -> x + y) 0 [1,2,3,4,5] do not evaluate properly.

I believe this has to do with lambdas always having type Dynamic -> Dynamic.

Implement integer ranges like in Haskell

Implement generalized do notation.

Attempt to show non-IO actions in the REPL.

Allow for the specification of monad generic functions in InterpreterContext.

Currently these have to be specified one-by one, e.x. a forEach for IO, a forEach for List, etc...

It would be really nice if we could specify these polymorphically somehow. I'm not entirely sure how that would work.

Implement records.

Implement "Smart Indentation" in the interpreter.

e.x. if I start typing:

main = {

I want the next line of the interpreter to be indented by four spaces.

Add the ability to make recursive definitions.

Implement a basic REPL.

Add some tests for the parser/interpreter

Publish to hackage

Implement floating point literals.

Add the capability to add new definitions in the interpreter

Allow way of specifying variance of Haskell data types.

In order to properly act on Dynamic data with higher-order functions, we'll probably need to consider variance (e.x. implicitly lifting a [Int] to a [Dynamic]. We want this to be able to be specified for an arbitrary Haskell data type to keep things extensible.

This may also be relevant for features like functor/applicative/monad polymorphism. e.x. if f : Int -> Int and x: [Int], we could say f x, and have that automatically lifted to map f x. This I think is the general idea behind what I was thinking of as "reactive polymorphism".

f = \x y -> x
g = f 2

> g 3
3 -- (expected 2)