| {-# OPTIONS --type-in-type #-} | |
| open import Agda.Builtin.Equality | |
| open import Agda.Builtin.Bool | |
| open import Agda.Builtin.Nat | |
| open import Agda.Builtin.Sigma | |
| open import Agda.Builtin.List | |
| data Void : Set where |
| {-# LANGUAGE LambdaCase #-} | |
| {-# LANGUAGE PartialTypeSignatures #-} | |
| import Data.Char (isNumber, isSpace) | |
| infixl |> | |
| v |> f = f v | |
| main = do | |
| print "Hey! I am ready to accept input :)" |
| import Data.List | |
| infixl /// | |
| class LaxDivision a where | |
| (///) :: a -> a -> a | |
| instance LaxDivision Int where | |
| (///) = div |
Somehow, it is not possible to lie. These things are with the definiteviness of a combinatorial object. They are not fractals.
I heard one man once said that homological algebra is the most remarkable thing that has been discovered. In most unlike places I noticed glimpses of its presense.
This just does not feel real I really wonder if same technique can be applied in the realm of synthetic biology.
| import Foundation | |
| func fix <A>(_ f : (A) -> A) -> A { f (fix (f)) } | |
| // _ = fix { _ in } | |
| indirect enum N { | |
| case s(N), z |
Dislcaimer: you can click this, then watch this, then find on net lanugage Terra to grasp a bit of what I am talking bout. Multistage metaprogramming is a big, unrealised area of research. I want a thing kinda like that, but better; with deeper integration with os/linker
During all my past, as long as I remember myslef, I noted that despite all major languages have had settled and now peacfylly stagnating, many newcomers represented by those like rust, haxe, zig, v, eta, and whatever few hundred other I missed, they inevitably will disappear without leaving a trace, because they all are mediocre. If you have been thinking along these lines that I am going to humiliate them, you gessed it right, I will. The all pieces of shit that came from people who either got so old it cut their ability to innovate, or total poseur, who cannot see world beyound their curriculum. It app
All info in this draft didnt come from my wild dreams. What I did is lurked for some research sitting in public university domains. It is amizing what highspeed unmetered internet connection and human with brains can do together. In short I just assembled some stuff to satisfy what I needed - A
language for ontology software creation and how it ought to look in 21st century.
You may see papers youself here
Let me be frank with you. All popular languages in use are bad. They all share a set of common design failures, plaguing some and sometimes all aspects of what programming discepline is meant to be - which is about making models that can be used by someone else to make more usefull stuff. Most of languages that have big repositories of useful frameworks, utilities etc do constrain the developer and its evolution in one way or another.
Swift is peice of crap. Since it's conception in 2013 no important features was added, and no problems was resolved. I regret about it, since there are points about which I am happy. It is one thing actually, visual aesthetic. Here are the list of features that would make swift the best.
<...> to designate a type variables. Instead take an approach of protocol associated types.class Box {
associatedtype Value
var value: Value
~Type Hierarchy - an ancestry representing what type is (class inheritance), and what type has (protocol conformance).
Currently swift allows to declare rich protocol hierarchies, which serve the purpose of abstracting building blocks of software, while also providing the minimal dependency requirements between such blocks. Being a language that relies on paradigm of objects and inheritance, swift also provides capabilities to give these interfaces (or protocols in swift' terminology) the default implementation for its members (which makes them essentialy mixins). A teqnique known as retroactive moddeling can easily expand type' inheritance network to be consisting of multitude of entities that each can provide unique implementation of some functionality, without limiting the ability of being a customization point.
| ``` | |
| //when ever you create an object and do not specify mutability specification | |
| //S-CLISP treats that object with whole range (iso..tag) mutability | |
| object Box {} //is similar to | |
| object iso..tag Box {} | |
| //this means that you can instantiate object with the mutability you need. | |
| //there is 6 mutability sybtypes for every object | |
| //iso - in local scope: one writer, one reader | |
| //trn - in local scope: one writer, many readers | |
| //ref - in local scope: many writers, many readers |