 many new tools and gadgets. Technology has changed our living style, education system, traveling, and the medical system. For example, if we talk about the internet, it has changed the world into a global village. We can communicate with our friends and relatives very easily via the internet.
There are many websites available on the internet with different types of content. For example, these days many people use dating websites to find their love and life partner. It has become a trend these days to find a partner on a dating site. POF or Plenty of fish is one of the most famous Canadian dating website founded in 2013. Now many people are using this website to find their compatible match over it.
Here you can find a partner according to your needs and requirements. You can choose a person according to his age, height, color, and other qualities. Now the question is how to delete POF account after finding a life partner? It is very simple to delete POF. If you are thinking about how do I delete my POF account, and then don’t worry now. In this piece of content, we will share simple and easy ways to delete POF within few minutes. You can delete POF account by using an android mobile phone, Apple iPhone, or via desktop computers.
As we all know that almost every person is using an android mobile phone these days and everyone has different apps on mobile phones. So, you can delete POF from your mobile by following the given steps.
Click cancel and say yes for confirmation.
This is the best way to delete POF account by using an android mobile phone.
For Apple users, it is very easy to deactivate POF account.
By using the above method you can remove POF account efficiently.
If you are a pc user, then it is very simple for you to remove your POF account. You can remove your account by following the given steps.
From the browser, log into www.POF.com.
Enter a username, password, etc.
In this way, you can deactivate or remove POF account without any kind of help or assistance.
If you don’t want to remove your POF account permanently, it is a good option to hide your account. In this way, you may use your account later according to your needs and requirements.
Now your profile has hidden and will not appear in any search results.
Repeat the same steps to unhide your POF account.
There are many reasons why you want to delete your POF account. For example, you may have found the perfect partner or want to use other dating sites. Whatever the reason, you should try to delete your POF account efficiently to avoid any kind of inconvenience in the future. So, if you are still thinking about how do I delete my POF account or how to delete POF account? Then just follow any method from the mention above. By following the above methods, you can securely delete your account.
Q: Infer HList type when building the list with a macro I have a method taking an HList and using it to build an instance of a class.
I would like to provide some simplified syntax, hiding the explicit cons. So I'd like to go from:
MyThingy.describe( 42 :: true :: "string" :: HNil)

to 
MyThingy.describe {
  42
  true
  "string"
}

where MyThingy is defined like
class MyThingy[L <: HList](elems: L)

I've made an attempt with this macro
def describe[L <: HList](elements: Unit): MyThingy[L] = macro MyThingyMacros.describeImpl[L]

and
def describeImpl[L <: shapeless.HList : c.WeakTypeTag](c: Context)(elems: c.Tree): c.Tree = {
  import c.universe._

  def concatHList: PartialFunction[Tree, Tree] = {
    case Block(l, _) =>
      val els = l.reduceRight((x, y) => q"shapeless.::($x,$y)")
      q"$els :: shapeless.HNil"
  }

  concatHList.lift(elems) match {
    case None => c.abort(c.enclosingPosition, "BOOM!")
    case Some(elemsHList) =>
      val tpe = c.typecheck(elemsHList).tpe
      q"new MyThingy[$tpe]($elemsHList)"
  }

}

but the typechecker explodes:

exception during macro expansion:
  scala.reflect.macros.TypecheckException: inferred type arguments [Int,Boolean] do not conform to method apply's type parameter bounds [H,T <: shapeless.HList]

Apparently the compiler is trying to infer [Int, Boolean] from the block before the macro expansion. I also don't understand why it requires two parameters, where describe and MyThing only require one.
Is there a way to have type inference driven by the tree produced by the macro?

A: If you can live with a comma separated argument list then you could follow the style used in shapeless's HList companion object apply method,
scala> import shapeless._
import shapeless._

scala> object MyThingy {
     |   def describe[P <: Product, L <: HList](p : P)
     |     (implicit gen: Generic.Aux[P, L]) : L = gen.to(p)
     | }
defined object MyThingy

scala> MyThingy.describe(42, true, "String")
res0: this.Repr = 42 :: true :: String :: HNil

scala> res0.head
res1: Int = 42

In general my recommendation is to avoid macros if there is a viable non-macro alternative.

A: I'm going to respectfully disagree with Miles a bit here. I personally can't stand auto-tupling, and if you want to use -Xlint in your project, the solution in his answer is going to cause a lot of warning noise. I definitely agree that you should avoid macros when there's a viable alternative, but if I had to choose between auto-tupling and a macro in a case where I'm just providing syntactic sugar, I'd go with the macro.
In your case this isn't too hard—there's just a minor error (well, two, really) in your logic. The following will work just fine:
import scala.language.experimental.macros
import scala.reflect.macros.whitebox.Context
import shapeless._

class MyThingy[L <: HList](val elems: L)

def describeImpl[L <: HList: c.WeakTypeTag](c: Context)(elems: c.Tree) = {
  import c.universe._

  def concatHList: PartialFunction[Tree, Tree] = {
    case Block(statements, last) =>
      statements.foldRight(q"$last :: shapeless.HNil")(
        (h, t) => q"shapeless.::($h, $t)"
      )
  }

  concatHList.lift(elems) match {
    case None => c.abort(c.enclosingPosition, "BOOM!")
    case Some(elemsHList) =>
      val tpe = c.typecheck(elemsHList).tpe
      q"new MyThingy[$tpe]($elemsHList)"
  }
}

def describe[L <: HList](elems: Any): MyThingy[L] = macro describeImpl[L]

Or more concisely:
def describeImpl[L <: HList: c.WeakTypeTag](c: Context)(elems: c.Tree) = {
  import c.universe._

  elems match {
    case q"{..$elems }" =>
      val hlist = elems.foldRight[c.Tree](q"shapeless.HNil: shapeless.HNil")(
        (h, t) => q"shapeless.::($h, $t)"
      )
      q"new MyThingy($hlist)"
    case _ => c.abort(c.enclosingPosition, "BOOM!")
  }
}

The biggest issue was just in the reduction—you need to start with the HNil, not build up a meaningless intermediate thing and then tack it on. You also need to capture the block's expression, and type it as Any instead of Unit to avoid value discarding.
(As a side note, I'm a little surprised this works as a whitebox macro, but as of 2.11.2 it does.)
I personally prefer this syntax with commas, though, and that's also pretty easy:
def describeImpl[L <: HList: c.WeakTypeTag](c: Context)(elems: c.Tree*) = {
  import c.universe._

  val hlist = elems.foldRight[c.Tree](q