Commit cc1336f8 authored by Nicolas Lenz's avatar Nicolas Lenz

Update ''

parent e57d54f2
......@@ -27,6 +27,7 @@ Good GUI solutions are important. Haskell still has no reasonable GUI solutions,
- Look into [Idris Effects](
- Look into [Functional Reactive Programming]( ( [reactivebanana](
- Not sure I like that…
- Monad typeclasses instead of transformers (`MonadIO`, `PandocMonad`…)
- `katrin shell` usable as full command shell (replacing bash etc.) (→ innaytool)
- Things like piping etc. possible with type-safety
- How to most elegantly integrate non-Katrin programs?
......@@ -38,14 +39,17 @@ In the real-world, working with external data in file systems and databases is o
- Communication with databases/files/servers/users should be easy and type-safe.
- Implicit typed reading of files (integration with typed file system of CrystalOS)
- ~~*Languages* (regular, context-free) at the language heart~~
- Probably nonsense
- *Probably* nonsense
### Miscellaneous
- Typeclasses are called »traits« (→ Rust)
- Named trait instances (→ Idris)
- Infix/Prefix/Custom argument placement (→ Agda)
- Probably a bad idea
- Totality enforced by default (no `fromJust`, `error` etc.)
- Do the pros outweigh the cons here?
## Influenced by
......@@ -76,9 +80,10 @@ One tool for everything: `katrin` command line tool is compiler, interpreter, sh
- `katrin test` runs a Katrin test suite.
- `katrin fmt test.katrin` formats a source file following the standardized coding conventions and an optional custom format specification.
- `katrin lint test.katrin` gives hints on how to improve a source file.
- Integrate into `compile`?
- `katrin language-server` starts a language server for editors supporting the protocol.
YAML files are used for configuration as they're human-friendly.
YAML files are used for configuration as they're especially human-friendly.
### Debugging
......@@ -109,10 +114,16 @@ Follow the Zen of Python principles. (?)
- Allow flexible function syntax like in Agda?
- Idris has a syntax statement for that, maybe that's better. Deviating syntax should be disicentivized to keep stuff consistent
- Something like `x <elementOf> list` is clearly more expressive than `x elementOf list` where you can't know wether x or elementOf is the actual function. And I can't think of many situations where non-explicit non-standard function application syntax would be a good idea
- if-then-else is an exception
- How to handle that? Syntx statement sounds good.
- Disincentivize special characters only operators. Better `<map>` than `<$>` or `<parse>` than `.:!`
- That also poses a lot of problems for the parser
- if-then-else might be an exception
- How to handle that? Syntax statement sounds good. Still difficult for the parser
- Or simply disallow it and do something like `if (a == 0) (print "0") (print "Not 0") but that might be less readable
- Disincentivize special characters only operators. Better `<map>` than `<$>` or `<parseKey>` than `.:!`
- Far easier to comprehend.
- Basic stuff like `<$>` might still be okay, but then again, `<map>` really isn't that much longer (and maybe even easier to type).
- Prefer meaningful names in general (looking at you, Haskell!).
- Records in Haskell are deeply flawed. Fix that, they're really importent in practice! Bring in the dot operator (as some people also did for Haskell).
- One of the pros of OO-programming is that you can set a paramater for a whole class and then all functions of the class can use that. Without that functions calls sometimes get awkward when you have to pass the same parameters (config, server URL) over and over again. There are ways to alleviate that, maybe find something elegant to integrate into the language?
- Something like singletons? Constants that can be set on module load? Something like that
- Stay functional and type-safe of course
- Maybe dependent types can be useful for this?
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment