Injection / Bijection wanted?

[sritchie]

Hey guys,

I'm the author of Twitter's Bijection library in Scala, and have found the Injection and Bijection typeclasses to be extremely useful. I'd love to get these, and a few other typeclasses, into swiftz. Here's some extremely early playing around:

// Playing around with the Injection typeclass.
protocol Injection {
    typealias T
    typealias U
    func apply(T) -> U
    func invert(U) -> T?
}

class IntInjection: Injection {
    func apply(i: Int) -> String {
        return String(i)
    }
    func invert(s: String) -> Int? {
        return s.toInt()
    }
}

let i = IntInjection()
i.apply(10)
i.invert("10")

Would you guys be interested in taking this pull req? I don't want to send it over if this is beyond the library scope.

One other Q:

• Would you take pull reqs for implementations of associative datastructures like those in Algebird? Or is Swiftz meant to contain typeclasses only?

[sritchie]

Another extension to Monoid I was playing around with:

// This protocol allows you to call plus directly on an instance.
protocol Addable {
    func plus(x: Self) -> Self
}

// And an example of how to implement Addable for some type.
// This feels repetitive... there's certainly some better way to write this thing.
extension Int: Addable {
    var monoid: IntMonoid { return IntMonoid() }
    func plus(x: Int) -> Int {
        return monoid.plus(self, x);
    }
}

Let me know!

[cartazio]

@sritchie if you renamed your Injection stuff to "read and show" or "printable" and "readable" yes. They're not bijections.

@sritchie addable is just Semigroup. We have that merged in already https://github.com/maxpow4h/swiftz/blob/master/swiftz/Semigroup.swift

I'm pretty sure we've got a lot of semigroup / monoid stuff,but having decent counting structures could be cool. though it might be a good idea to be conservative on how much gets in, i'm not sure how often ios/os x applications need server class approximate counting data structures.

I assume you mean the stuff in https://github.com/twitter/algebird/tree/develop/algebird-core/src/main/scala/com/twitter/algebird ?

[mxswd]

@sritchie Hey!

I am absolutely taking any PRs of associative data structures, like in Algebird.

As @cartazio mentioned, I have added a couple of instances semigroup and monoid. They are here. https://github.com/maxpow4h/swiftz/blob/27031fea2ce7496715e4d5345149fd8f156b24e5/swiftzTests/swiftzTests.swift#L268-L277

More useful instances would be very good! I just added those ~3 to define a Monoid type that can satisfy lots of different problems. (The technique I use in Monoid stops you from needing an Int, Int8, etc. version of everything).

As for Bijection / Injection, they would be very useful! My only ask, is if you could name them Isomorphism and Prism respectively.

Thanks! 😃

[jonsterling]

@maxpow4h I was not aware that prisms were injections?

[Sorry folks, pressed the wrong button there!]

[cartazio]

@maxpow4h oh, those are Lens Isos? I thought it was A->String and String->A only, rather than proper Isos ala lens

[mxswd]

@jonsterling That protocol is a Simple Prism. I.e. Prism s s a a.
But I don't think we can support polymorphic lenses any time soon ;)

[cartazio]

ohh, yeah, they are Isos and prisms, my bad :)

[sritchie]

Oh man, somehow i wasn't getting updates for this thread. Glad I checked in. Let me read up, one sec.

[sritchie]

@cartazio As the author of that library, I COMPLETELY understand, and will for all time, that those examples are not Bijections. That doesn't mean that bijection isn't a useful typeclass. (The Bijection library is mostly full of injections,btw.)

@maxpow4h about the Monoid and Semigroup, I did a bit more playing around and came up with this:

https://gist.github.com/sritchie/27bdf9329027d5cdf02e#file-algebra-swift-L70

Using "Self" removes the need for the duplication in the type parameter. You also don't have to supply the monoid or semigroup instance as the first argument anymore.

Happy to make that change too and update the tests if you're interested.

[sritchie]

@cartazio that's correct about those algebird data structures, I'd love to get some of those in.

[sritchie]

@maxpow4h about the Injection as a Prism, I'll have to read up.

[cartazio]

@sritchie the idea is the a-> Either a b is an injection (aka prism)
because you can't write a safe Either a b -> a

[sritchie]

@cartazio yeah, I get that (the injection vs bijection thing). It's a prism vs an injection because of the extra type parameter on Either, correct?

[cartazio]

http://hackage.haskell.org/package/lens-4.2/docs/Control-Lens-Prism.html#g:2 shows some machinery for prisms

replicating it inline

type Prism s t a b = forall p f. (Choice p, Applicative f) => p a (f b) -> p s (f t)

-- some ways to construct prisms
prism :: (b -> t) -> (s -> Either t a) -> Prism s t a b

--- a way to construct a simple prism
prism' :: (b -> s) -> (s -> Maybe a) -> Prism s s a b

[cartazio]

so in the really simple case we could have

prism' :: (a-> s) -> (s -> Maybe a) -> Prism s s a a

where s= Either a b
might be one choice in s

(this is just a teeny piece of the awesome generality of lens (which I myself am still learning))

so a simple prism might be formed out of

foo :: a-> Either a b 
bar :: Either a b -> Maybe a

[mxswd]

Yeah, so #34 has convinced me Control.Lens is not useful in Swift, but Data.Lens is.

So a "Prism", which would be a Function, becomes a class.

protocol Prism {
  let apply: A -> B
  let invert: B -> A?
}

exactly the same as the --Bijection-- Injection class definition.

Edited that, accidentally hit ctrl enter

[mxswd]

We are talking about the same things, I would just prefer to use the Lens version of terminology 😃

[cartazio]

'Bijection class definition.' dont you mean injection?

[mxswd]

Yes.

[CodaFi]

Advancement of the Data.Lens stuff makes this issue a bit irrelevant at the moment. Closing.