Forem: liron_hazan

Type Thinking 🤔 P2 - Typeclass

liron_hazan — Fri, 08 May 2020 15:39:19 +0000

In this post I shortly compare:

Haskell Typeclass
Rust Trait
Typescript type constraints

Demystifying some big words (wikipedia definitions):

Polymorphism - (many forms) "Polymorphism is the provision of a single interface to entities of different types"

I remember facing "polymorphism" when I just started to learn Java as a first OOP lang (~8 years ago).
The teacher taught us that one of the basics principles of an OOP lang is "polymorphism".
Whenever I hear of it I think of the famous animal example. having "Animal" class which the "Dog" and "Cat" inherit from and I can iterate a collection of Animals and invoke the "makeSound()" function they all implement cause they all of the same type (object) - "Animal".

But If being honest I don't remember the last time I used inheritance (even the prototype kind..) I usually define a structure type by an interface and defines another "behavioural" interface containing the methods I need to implement. (a matter of taste? Or a better segregation...).

Ad hoc polymorphism or just overloading: "Defines a common interface for an arbitrary set of individually specified types". on top of that we have functions overloading - the ability to create multiple functions of the same name with different implementations (handled by the compiler).
Parametric polymorphism "A way to make a language more expressive, while still maintaining full static type-safety" (Generics..)
Dynamic Dispatch - The process of selecting which implementation of a polymorphic operation (method or function) to call at run time.

Definitions:

TypeClass	Trait	Interface
A type system construct that supports ad hoc polymorphism. This is achieved by adding constraints to type variables in parametrically polymorphic types. If a type is a part of a typeclass it should implement the behavior described on that typeclass.	A trait is a language feature that tells the Rust compiler about functionality a type must provide	We use an interface to define a shape and we use Generics constraints for saying that a certain behaviour (or an attribute) is required by a type.

Examples:

Haskell:
Following example is from: learnyouahaskell

data Person = Person { firstName :: String  
                     , lastName :: String  
                     , age :: Int  
                     } deriving (Eq) 

let adRock = Person {firstName = "Adam", lastName = "Horovitz", age = 41}  
let mca = Person {firstName = "Adam", lastName = "Yauch", age = 44}  
-- mca == adRock will be false

I'm far of being an haskell developer but it seem to fit the typeclass definition, there's a class Eq, it contains "==" and "/=" functions,
deriving (Eq) tells the compiler to generate instance of the Eq class for the Person type, this way it implements / has the "==" "/=" operators.

Rust:

trait NoisyAnimal {
    fn make_noise<'staic>(&self) -> &'staic str;
}
struct Cat{}
impl NoisyAnimal for Cat {
    fn make_noise<'staic>(&self) -> &'staic str {
        "meow"
    }
}

struct Dog{}
impl NoisyAnimal for Dog {
    fn make_noise<'staic>(&self) -> &'staic str {
        "woof"
    }
}

fn make_noises(animals: Vec<Box<dyn NoisyAnimal>>) {
                        //       ----- trait object
    for animal in animals.iter() {
        println!("{}", animal.make_noise());
    }
}

fn make_noises_with_constraints<T: NoisyAnimal>(animal: T) {
    println!("{}", animal.make_noise());
}

pub fn call_make_noises() {
    make_noises_with_constraints(Dog{});

    let animals: Vec<Box<dyn NoisyAnimal>> = vec![
        Box::new(Dog{}),
        Box::new(Cat{}),
    ];
    make_noises(animals);
}

Struct is a type that is composed of other types. (in Typescript we model in an interface). In the above example we're implementing the trait obj functionality to 2 structs Cat & Dog.
The make_noises fn iterates a vector of types that implements the trait object (dynamic dispatch) - pretty cool :D.
I also created the make_noises_with_constraints() methos which demonstrates a trait constraint which is more relevant to the concepts I raised..

Typescript:


interface Instrument {
    play: () => void;
}
class Guitar implements Instrument {
    play() {}
}

class Drums implements Instrument {
    play() {}
}

function playPart  <T extends Instrument>(instruments: T[]) : void {
    for (const instrument of instruments) {
        instrument.play();
    }
}

playPart([new Guitar(), new Drums()]);

Using Generics constraints I'm not limiting the playPart() function for a single type of instruments, we can make sound of many things, e.g. a bottle of beer, so in case that bottle implements the Instrument interface, it will be playable - (which could be a better name actually :P ).

Cheers,
Liron.

Type thinking P1 - Types

liron_hazan — Tue, 28 Apr 2020 10:54:52 +0000

Types addiction.. no "taxes" or bulshit ;)

Prologue: This post is the 1st of a series of short posts on comparing type exists in Haskell to their Typescript & Rust equivalents.
For the past few months I've been on/off learning Rust and Haskell and that's an excuse to practice while wondering some fun theoretical stuff..

What are types?
Type Theory?
What's HKT (Higher kind types) - typing types ?

Types as explained by the Haskell perspective:

Instead of pasting the wikipedia explanation of a type system, let's review the Haskell like explanation from learnyouhaskell:

" A type is a kind of label that every expression has. It tells us in which category of things that expression fits. The expression True is a boolean, "hello" is a string, etc. "

Type Theory

My guess is that I'm NOT gonna be an expert in Category, Types or Sets theories, but learning in high level and slowly deeping the knowledge is a good thing… and grasping types is an integral part of our logic.

I recently discovered nLab (kind of a wiki for our topic but not exactly..) for future digging in theories, follows is the nLab definition of type theory:

" Explicitly, type theory is a formal language, essentially a set of rules for rewriting certain strings of symbols, that describes the introduction of types and their terms, and computations with these, in a sensible way."

HKT - higher kinded types

Let's start demystifying the big words…

A kind is the type of a type constructor.
A type constructor is a feature of a typed formal language that builds new types from old ones.

Higher Kinded Types are types who take types and construct a new type of them.
In Haskell the kind of Maybe is * -> *.

We don't have HKT on Typescript (not sure we need another abstraction, TS transpiled to JS anyway and it's not statically typed, it's gradually typed meaning we can still have untyped variable by using "any"..)

My first thought of HKT was: "we have Generics" but that's wrong cause Generics let us describe data types (values) and a Generic cannot use another Generic.

interface TypeA<T> {
  foo: T
}

// I want to describe a type that is of Type A or null
// type maybe_A = TypeA<*> | null; // I can't

type maybe_any_A = TypeA<any> | null; // I can do that but I guess the point of HKT will be lost

type maybeA = <T>(t: T) => TypeA<T> | null; // now the type of maybe A is a function that maybe returns A

Feel free to feedback if you think I've got that wrong :)

References:

Bartosz Milewski Category Theory series
Dr. Erik Meijer - Functional Programming Fundamentals (C9)
https://ncatlab.org/nlab/show/type+theory
https://gist.github.com/gcanti/2b455c5008c2e1674ab3e8d5790cdad5

Cheers,
Liron.

Micro-interactions in Angular

liron_hazan — Fri, 21 Feb 2020 07:23:32 +0000

Hey Everyone, this is actually my first post in dev.to :)

I want to share with you a tiny library I wrote for easily adding micro-interactions into your Angular app.

HIT THE DEMO

My lib is based on Web Animations ( experimental API ) which is one of the most performant ways of making animations for the web.

To use ng-micro-interact in your Angular project do the following:

Install: npm i ng-micro-interact
Import NgMicroInteractModule into your consumer module.
Use the ngMicroInteract directive on any element you want to interact with.

Thanks for reading this post!
I will really appreciate if you'll star the repo.