Question: So i have searched a lot about showing a place in google maps, but all of tutorial show a technique which requires Latitude and Longitude, but can someone please tell me a trick where i can achieve this using just the address string ? Thank you

Answer: 
You might want to look at [GHC.Generics](http://www.haskell.org/haskellwiki/GHC.Generics). It basically encodes each ADT as products (`(,)`) and sums (`Either`). As an example, here is how you could show this representation using generics:

```
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
import GHC.Generics

class Tuple p where
  showRepresentation :: p -> String

  default showRepresentation :: (Generic p, GTuple (Rep p)) => p -> String
  showRepresentation = gshowRepresentation . from

class GTuple p where
  gshowRepresentation :: p x -> String

instance Tuple k => GTuple (K1 i k) where
  gshowRepresentation (K1 t) = showRepresentation t

instance GTuple f => GTuple (M1 i c f) where
  gshowRepresentation (M1 f) = gshowRepresentation f

instance (GTuple f, GTuple g) => GTuple (f :*: g) where
  gshowRepresentation (f :*: g) = gshowRepresentation f ++ " * " ++ gshowRepresentation g

-- Some instances for the "primitive" types
instance Tuple Int where showRepresentation = show
instance Tuple Bool where showRepresentation = show
instance Tuple () where showRepresentation = show

--------------------------------------------------------------------------------
data Example = Example Int () Bool deriving Generic
instance Tuple Example

main :: IO ()
main = putStrLn $ showRepresentation $ Example 3 () False
-- prints: 3 * () * False

```

You can find more documentation in the [GHC.Generics](http://hackage.haskell.org/package/base/docs/GHC-Generics.html) module. I also found the paper about it, [A Generic Deriving Mechanism for Haskell](http://dreixel.net/research/pdf/gdmh.pdf) to be quite readable (it was one of the few papers I read).
The [lens](http://hackage.haskell.org/package/lens) library, in modules [Control.Lens.Iso](http://hackage.haskell.org/package/lens-4.1.2/docs/Control-Lens-Iso.html) and [Control.Lens.Wrapped](http://hackage.haskell.org/package/lens-4.1.2/docs/Control-Lens-Wrapped.html), has a few utilities that make working with such conversions easier. Unfortunately, at the moment the Template Haskell [machinery](http://hackage.haskell.org/package/lens-4.1.2/docs/Control-Lens-TH.html#v%3amakeWrapped) for such cases does not handle records, only newtypes, so you'll have to define the instances yourself. For example:

```
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeFamilies #-}

import Control.Lens

data Foo = Foo { baz :: Int, bar :: Int } deriving Show

instance Wrapped Foo where
  type Unwrapped Foo = (Int,Int)
  _Wrapped' = iso (\(Foo baz' bar') -> (baz',bar')) (\(baz',bar') -> Foo baz' bar')

```

Now we can wrap and unwrap easily:

```
*Main> (2,3) ^. _Unwrapped' :: Foo
Foo {baz = 2, bar = 3}

*Main> Foo 2 3 ^. _Wrapped'
(2,3)

```

We can also modify a `Foo` using a function that works on the tuple:

```
*Main> over _Wrapped' (\(x,y)->(succ x,succ y))  $ Foo 2 5
Foo {baz = 3, bar = 6}

```

And the reverse:

```
*Main> under _Wrapped' (\(Foo x y)->(Foo (succ x) (succ y)))  $ (2,5)
(3,6)

```