text:
Anupam Goel
As billionaires race to fund anti-aging projects, a much-discussed trial goes overlooked
By Anupam on 2022-08-09
"[Nir] Barzilai, the head of the Institute for Aging Research at the Albert Einstein College of Medicine, and scientific director for AFAR — the American Federation for Aging Research — has for more than a decade been leading the charge to test the idea of using drugs to extend human healthspan.
In 2013, he and two other researchers got a grant from the National Institutes of Aging to develop a roadmap to conduct, for the first time in history, a clinical trial that targets aging. They planned to test metformin, a drug that had been approved in the '90s for treating diabetes, and that was shown in epidemiological studies to prevent against conditions like heart attacks, cancer, and Alzheimer's. It also turned out to be very safe, with few, generally mild side effects. And it's dirt cheap: just six cents. per dose. [..]
Barzilai's plan was to launch a new kind of gold-standard trial, designed to prove that the onset of multiple chronic diseases, or comorbidities, associated with aging can be delayed by a single drug: metformin. The ambitious effort aimed to track 3,000 elderly people over five years to see if the medicine could hold off cardiovascular disease, cancer, and cognitive decline, along with mortality. [..]
"Those big billionaires, they want moonshots, they want a scientific achievement that will make people say 'wow,'" said Barzilai. "TAME [Targeted Aging with Metformin trial (approved by the FDA, but never funded)] is not a moonshot. It's not even about scientific achievement really, it's more about political achievement. Metformin is a tool to get aging as an indication."
Like many other industry players and academics STAT spoke with, [co-founder and CEO of Cambrian Biopharma James] Peyer believes the TAME trial could be a paradigm-shifting pilot experiment and create a framework for biotechnology companies to follow in the future. "If we had more knowledge from a philanthropically run trial with a really safe molecule, that would be a boon for the whole field. It would be huge. But it's been more than six years since the FDA gave a green light. It should almost be done by now," Peyer said."
Full article, M Molteni, STAT, 2022.8.9
Posted in: Clinical Innovation
Healthcare Workforce Shortages cannot be Resolved unless Self-Care is Taken Seriously
Aldosterone, a hormone that prevents dehydration, is linked to worsening kidney disease, study suggests
Behavior Change (10)
Care Delivery Innovation (43)
Clinical Innovation (15)
Digital Identity and Privacy (5)
Health communication (17)
Health Information Technology (32)
Drug Pricing (9)
High-value Care (38)
International Comparisons (3)
Measurement (25)
Payment Innovation (15)


After spending several years in the 1960s playing Don Draper (and not taking home any hardware yet), Jon Hamm is kind of like,Well, I guess I could maybe play a hologram? Sure, why not? Deadline reportsthat the actor is in talks to costar in an adaptation of the sci-fi dramedy Marjorie Prime, the story of an ailing violinist enduring the rest of her existence in an assisted-living facility with a therapeutic, holographic companion.


text:
WritingBros
Log In Hire Writer
Home Essay Samples Entertainment Movies The Patriot Celebration of American History and Heritage in The Patriot
Celebration of American History and Heritage in The Patriot
History, Life, Entertainment
History of The United States, Personal Finance, Movies
American History, Heritage, The Patriot
1367 (3 pages)
Watch out! This text is available online and is used for guidance and inspiration
Get Custom Essay
The award winning movie, "The Patriot", starring Mel Gibson as the main character Benjamin Martin, Heath Ledger as Benjamin Martin's son Gabreil Martin and Jason Issacs as Colonel William Tavington, was directed by Roland Emmerich and later released in 2000. I watched this movie on a Saturday night with my step-dad who is a history fanatic. I chose to watch this film because of how much positive feedback I was given from fellow friends and family members who have watched the movie themselves, which all reassured me that this movie would tie perfectly with the historical theme of my paper, and simply be a "really good one." They weren't wrong! The historical theme displayed throughout the movie, "The Patriot", covers the Revolutionary War ear, focusing primarily on the tactics used by the colonial militias, as well as British atrocities. By watching this movie, I think it's going to benefit me on my AP exam because not only am I a visual learner, but this movie was genuinely intriguing and in its own way the scenes throughout the movie were educational, giving me things to remember it by. This movie definitely emphasized the role that colonial militias played in the war effort. I wasn't aware of just how much the French aided the colonists, not only by sending over weapons and troops, but by sending prized military leaders that would come to train some of the colonial militias. Before watching, "The Patriot", I had no idea what great amounts of effort, blood, and time was put into the Revolutionary War.
The movie begins with the main character, Benjamin Martin, and his family partaking in their normal routine on their plantation. Benjamin is a widowed veteran that is well known for his actions during the French and Indian War. Faced with war once more, the start of the Revolutionary War calls upon him to guide, lead, and take on such a challenge, but with all that he's been through Begamin is well opposed to it and would rather not be involved whatsoever. Despite Benjamin's strong feelings toward the war his oldest child, Gabriel Martin, decides he wants to fight for the cause of independence goes against his father's wishes by joining the war. It is later on that Gabriel returns home wounded, followed by a group of redcoats who come in search for him trying to convict him of treason with a sentence of dead, more specifically hanged. Gabriel's little brother, Thomas Matin, acts out in opposition and runs to Gabriel trying to save him and sadly, while doing, Thomas ends up shot and dead by Colonel Tavington. The result of such events and the loss of his very own son sparks overwhelming feelings of hatred, anger, and frustration in Benjamin Martin.
As a result of such loss, though Benjamin had previously convinced himself that he wanted nothing to do with the war before, he now finds himself wanting to fight against the British, and he goes on to do so. Benjamin strategically plans an attack on a group of British redcoats, the ones that killed Thomas, which become the major turning point in the movie because it marks Benjamin transition of opposition towards war to his determined involvement in it. After sending the rest of his children to live on their aunt's plantation, Benjamin and Gabriel put together a militia. While recruiting men for the militia Gabriel sees Ann, his childhood friend, and the two quickly form a loving bond. Meanwhile, the militia under Benjamin Martin's leadership soon completed numerous successful attacks on the British using unorthodox tactics to catch them off guard resulting in Benjamin earning the title of "The Ghost" by the British. Later, during one of the militia's attacks, they realize Colonel Taviington has come more prepared than what they expected as a couple members of the militia were killed and others taken as prisoners, while the rest narrowly escape Tavington and his army. In attempts to save the men that were captured and regain power, Benjamin makes a peaceful agreement with Cornwallis to give him back his dogs and release the lieutenants and other persons of power in the British army that Benjamin Martin's militia "captured." Cornwallis agrees but realizes that Marin tricked him after it was too late.
We will write a unique paper on this topic for you!
*No hidden charges
With much rage, Cornwallis tells Tavington that he wants him to capture and kill Benjamin Martin along with his militia, which then becomes another turning point as it establishes the intense rivalry between Tavington and Benjamin Martin, as Tavington now truly has it out for Benjamin. Tavington's army begins killing innocent townsfolk including the loved ones and families of many of the men in the militia. When Benjamin realizes this, he orders a week long intermission for the militia. During this time Gabriel and Ann get married. Shortly after Ann returns home but is killed when Tavington and his army burned the church while she was being held in. This infuriates Gabriel, and he starts a movement with a few other members of the militia and they go off to fight Tavington's army. Towards the end of the battle the only two left are Tavington and Gabriel. Gabriel makes a move and thinks he killed Tavington's chances, but Tavington was fooling him and Gabriel, falling for it took his time finishing off Tavington, allowing him to make the first move and turn the tables killing Gabriel. Benjamin arrives too late to save his beloved son, Gabriel, and seemingly loses hope for a little while, but he soon decides that he will keep fighting for the cause so that the British can't have the satisfaction of taking anything or anyone else away from him. Benjamin soon meets with the continental army and engages in a grueling and damaging battle, the militia suffers, but soon regains power with Benjamin Martin's leadership and determination. Benjamin and Tavington are both out for each other, and eventually meet and engage in fierce battle using swords, Benjamin heroically defeats Tavington and Cornwallis retreats allowing for huge surge of optimism and nationalism for the cause for independence. The movie ends with Benjamin returning home to find his freed slaves and family working on rebuilding his home.
Though all the characters are fictional, Benjamin Martin, the main character, seems like he could be loosely based off many real historical figures from the Revolutionary War like Daniel Morgan, Elijah Clark, Thomas Sumter, Andrew Pickens, and more specifically Francis Marion. This is partly historically accurate as Benjamin Martin was a heroic militia leader in South Carolina in the movie, and Francis Marion too was a heroic militia leader in South Carolina reality. There were many real events portrayed in "The Patriot", however many of these are not completely historically accurate as a result of Hollywood propaganda. For example, towards the end of the movie, the Battle of Cowpens and Battle of Guilford Courthouse as the tactics used and the results align with actual tactics and results from those battle in reality, but was highly influenced by Hollywood propaganda in the movie. There were many things that were not historically accurate in "The Patriot" because it was dramatized and a result of Hollywood propaganda. The most criticized example of this is a misrepresentation of British atrocities during the war. In the movie, the British killed prisoners of war, children, and women. They burned down a church filled with people in the movie. Though in reality the British may have killed innocent women, children, and prisoners of war, but it was undocumented that it was not to the extent decepticed in the movie, there was also no record of the British actually burning a church full of innocent townsfolk.
It seems that the director, Roland Emmerich's, point of view regarding "The Patriot" is that American history should be celebrated, and we should be thankful for those that endure and fought through the Revolutionary War to establish America as an independent nation. I think that this movie was made a time of general stability in America to show and remind Americans of what these people did and went through to establish the independent America we know today, in an effort to promote and create a spark of patriotism and nationalism across the nation.
You can receive your plagiarism free paper paper on any topic in 3 hours!
*minimum deadline
To export a reference to this article please select a referencing style below
Celebration of American History and Heritage in The Patriot. (2021, January 12). WritingBros. Retrieved January 18, 2021, from https://writingbros.com/essay-examples/celebration-of-american-history-and-heritage-in-the-patriot/
"Celebration of American History and Heritage in The Patriot." WritingBros, 12 Jan. 2021, writingbros.com/essay-examples/celebration-of-american-history-and-heritage-in-the-patriot/
Celebration of American History and Heritage in The Patriot. [online]. Available at: <https://writingbros.com/essay-examples/celebration-of-american-history-and-heritage-in-the-patriot/> [Accessed 18 Jan. 2021].
Celebration of American History and Heritage in The Patriot [Internet]. WritingBros. 2021 Jan 12 [cited 2021 Jan 18]. Available from: https://writingbros.com/essay-examples/celebration-of-american-history-and-heritage-in-the-patriot/
A Civil Action
89 writers available online
Prof Solphie
Finished papers:
Prof. Lara
KellyEssays
Professor Harvey
Dr. Elin
Prof. Liam
Dr. Harold
Dr. Julie
Prof Japheth PHD
Academic Giant
Dr.Teddy
Dr. Harry PHD
Prof-Natalie
Prof Evander
The Integral Role of Women in World War II
Sigmund Freud as a Figure of Inspiration of Salvador Dali
Hybrid Vehicles as a Better Alternative to the Traditional Automobiles
My Personal Faith Statement and Vocation Plan
600 Words | 1 Page
Summary for Sherman Alexie's Movie Smoke Signals: The Story of ...
The Importance of Facing Adversity and Using It as an ...
Life of Pi: Journey of Values and Self-Exploration
Benjamin Frankiln's Recollection of Life in The Autobiography
Need writing help?
You can always rely on us no matter what type of paper you need
Order My Paper
About WritingBros
We provide a large database of college essays and cover almost any subject there is in the curriculum. Our goal is to help students excel in academic writing and successfully graduate. Find new ideas and inspiration using our free samples.
Still looking for a perfect essay?
writers available online
to start working on your essay just NOW!
Get Free Estimation
100% Unique Essays
Absolutely Confidential
Type in your email and receive this essay in a second
Send Essay
By clicking "Send Essay", you agree to our Terms of service and Privacy statement. We will occasionally send you account related emails
Uh-Oh, Copying is Forbidden
We'll be glad to send this essay to your email, though
Your sample
was successfully sent
You can also get a UNIQUE essay on this or any other topic
We'll contact you as soon as possible.

redpajama_set_name: RedPajamaCommonCrawl


text:
Romarie Bartley heads to Cuba in 2023 with funding from Sandal's Foundation
The Sandals Foundation has stepped in to fund Romarie Bartley's medical studies in Cuba, and he will leave the island on January 13, 2023 to begin reading for a degree in medicine.
And so, this Christmas will most likely be Bartley's last with his family in Jamaica for about six years.
"This has come to mind quite frequently as the year comes to a close. A lot of the things that have become a norm for me will soon end, as my departure time draws close.
To be honest, it's a mixture of emotions.
It's saddening, due to the great degree of incoming change, but exciting for that same reason.
The overall feeling, however, is gratitude for all I've been able to actually experience and the people I've met, inclusive of those I've only know since this year and the one prior," Bartley told the Jamaica Observer.
In November 2021, Bartley, the 2020-2021 head boy of St George's College, related to the Jamaica Observer that his dream of becoming a surgeon was in limbo, as his family had been hit by financial challenges.
Bartley, 20, was raised by his aunt in Greater Portmore, St Catherine, after his mother died when he was just three years old. He said his father has never been involved in his life.
Up to November 14, 2021, Bartley had accumulated US$260, and had his fingers crossed that he would be able to generate US$13,590 by November 26.
Much to his delight, Sandal's Foundation stepped in and cleared that hurdle.
"I was pretty happy and grateful. Not to sound pompous, but I wasn't surprised, because funding was something I've been praying about and had faith in.
I just wasn't sure where exactly it would be from or how, and now due to that faith that God would execute His will, I know the answer to those."
He will never forget the day when he heard the news.
"It was Friday, July 8. I had a virtual meeting with the foundation where they got to know me a bit more and my situation. This was before getting any promise of funding or anything like that.
I was actually at work and had to convert my work station to a semi-suitable area for a Zoom meeting and ask my co-workers to be as quiet as realistically possible," he recalled.
Later that evening, around 6:30, he saw that he had missed two calls and a voice note.
"I wasn't expecting any calls that seemed remotely like work but then I realised it was a Sandal's Foundation representative.
I was in the living room where my aunt and one of my brothers were already relaxing. The representative sounded super excited greeting me, unfortunately my exhausted self at the time couldn't muster up nearly that much excitement until she congratulated me and told me that the foundation agreed to fund the majority of my tuition," Bartley told the Sunday Observer.
"At that point, the adrenaline kicked in and the exhaustion went on standby. I was so happy hearing the news and extremely grateful to both the foundation and God for working this all out. They were quite excited for me, grateful toward the foundation and at ease."
Meanwhile, Bartley said that currently, there are no plans to do anything differently this Christmas to make up for those Christmas holidays he will be away pursuing his dream.
"My family has actually always been pretty subtle where the holiday season is concerned, and there's an odd comfort that has always come from it so I'd prefer not to tamper with that subtle yet sublime time.
However, at this time, I'm not sure if they'll try to surprise me with anything, big or small," he told the Sunday Observer.
Christmas Day, he added, is marked by church going. After church, the family would "take a few pictures then head home to just spend time together.
We'd have all the bed linings and curtains changed, food would be prepared and in the interim, we would eat Grotto bread and drink sorrel.
If we had Christmas cake then that would be split up after dinner."
Bartley described 2022 as a "box of gifts".
"This year has been a year with a lot of rough seasons and hard moments that, honestly, looked like curses, but they were, honestly, such a blessing. Proof of that is even in that sentence.
Had someone told me last year that for the majority of 2022 you'd be met with nos, discouragement, disappointments and confusion, I would definitely ask to opt out, but God has been really developing me through this time.
"It was through experiencing the less than ideal moments that I was able to see the gifts or blessings of this year. I had my faith strengthened which was actually on my vision board for this year, I even wrote a book of sorts on it.
I met some pretty amazing people, I learnt more about myself, I gained a deeper appreciation for those working in customer service, and oddly enough, in many other service jobs and I grew an even greater desire to be in the health field and to allow God to guide me in improving it."
SOURCE: Jamaica Observer
Well well well December 25, 2022 At 6:32 pm
Sandals Antigua planning to do likewise?
Over run with MDs and PHds and Do(entire alphabet) December 26, 2022 At 8:34 am
Why would they, there are much better things to do with$$$
SHERFIELD BOWEN SHOT TESSA BARTHLEY December 27, 2022 At 6:18 pm
All the best young man


Rock climbing is all about footwork. That's why choosing the right pair of climbing shoes may be the most important move a climber ever makes. Our extensive range of men's rock shoes covers every style of rock climb and every level of climber, from the fresh beginner to the seasoned pro.


text:
Monkeys, My Butt, and Politics.
Anyone sick of the political ads yet? Even though I love politics and love this season, this particular election has been especially irritating. There's absolutely no reason that President Obama should be remotely close to winning this election. His record is one of destroying jobs, not creating them. Putting our military in harm's way, not bringing them home. Weakening our presence overseas, not strengthening. Caving to international trade pressure, not strengthening markets for American products.
Yet, the pablum candidate on the other side, Mitt Romney, can't seem to get any traction. His middle of the road, moderate campaign doesn't seem to excite anyone, nor does he offer much in the way of alternatives to the current administration. Yes, I get it, that some things will change, but will they really be things that matter? Will Mitt REALLY stand up to the Chinese in regards to their tariffs on our goods exported to them (yes, we do actually export things to them) or will he continue the tradition that President Obama started by bowing and allowing them to do what they want? Will special interests still run the presidency, just different special interests? Instead of unions running the show, will it be investment bankers, the chamber of commerce, or some other master? Welcome the new boss, same as the old boss.
We need fundamental change, but change is hard. Change is uncomfortable and painful. No one can run on a national platform of "We're going to change, and it'll be painful, but in the long run it'll be better". Long view doesn't exist in America where 30 second soundbites lose the attention of the people halfway through. No one can say "We're going to cut the waste out of government and here is EXACTLY how we'll do it" and present a specific plan, because those who will be affected by the cuts will scream bloody murder. That's why Romney hasn't been that specific in his plans. You can't blame him. If he is to defeat the Chicago Machine that is in the White House now, he'll need every single vote he can garner, and giving people specifics as to how his presidency will cut money from their pet projects will not help him get those votes. Additionally, in this hyper-partisan environment, anything that the other side can do to gain an advantage, they are definitely going to take advantage. If that ends up hurting the country in the long term, so be it.
The system is broken and no one in power will fix it because it isn't to their advantage to do so. If we fix this broken system, people like Nancy Pelosi, Harry Reid, Mitch McConnell, Barack Obama, and the rest, no longer have power. Power is like a drug, you'll do anything to keep it, including subvert the stability of the government. These people have been doing that for years, under our noses. But, let's face it, it's not their fault. We have given them the power to do this. The American people have allowed these power-grabbing assbags to put themselves into a position to gain advantage through any method necessary. And have we stepped up to stop them? Ever? Perhaps the Tea Party movement is one where you can say that the people rose up and said 'enough', but that was quickly demonized by those in power, and the American people bought into the media/power structure's labeling of the Tea Party as 'racist', 'sexist', 'radical', etc. Really? Radical? Is it radical to want our government to stop spending more than they bring in? Is it radical to want the government to stick to their fundamental responsibilities and nothing more? Is it radical to want the people to have the power again, and not some faceless bureacrat who can't be fired no matter how incompetent? I don't think so, nor does the average American when asked. However, because the Tea Party threatened the existing power structure, suddenly it was 'radical'. Then co-opted by the Republican party, which could have been advantageous to the party, but instead they relegated them to the back of the proverbial bus. The Ron Paul movement could have revolutionized the Republican party, but instead of co-opting their ideas and bringing it into the mainstream of the party, they relegated them to the back of the bus as well. If the Republicans lose this election, they'll only have themselves to blame for the idiotic handling of these two extremely involved, and motivated groups.
It's time for a revolution. Not a shooting one, because that would only result in the slaughter of innocents, given that the government has exponentially more firepower than those of us who would stand up to them. But a thought revolution. One where people think for themselves and are more interested in voting for President than for the American Idol winner. And this is essentially an easy revolution to have. All we have to do is to get our neighbors to pay attention. I don't mean just in October/November of an election year, but all the time. Don't ignore politics outside of the election cycle. Call your senator/congressman/president when you think they're being an idiot. Or call them when you think they're doing a good job. But make sure they know that you're watching. And that your neighbors are watching. And your neighbors' neighbors. And their neighbors. We need to hold them accountable for what they're doing and stop suckling at the government teat ourselves. Stop complaining when someone says "Hey, we need to cut out this pet project" even if it brings tax dollars to your city/state/county/whatever. And give the politicians hell when they try to waste our tax dollars on such idiocy. Maybe if we do this, we'd see a return to fiscal sanity as well as a government where it's ok to give details about plans without having to worry about offending a special interest group because we're going to cut out research on the mating habits of the Southeast Asian Speckled Butterfly.
And maybe monkeys will fly out of my butt.
at 11/02/2012 08:08:00 AM 1 comment: Links to this post


Whether you're a student, technologist, marketer, or corporate analyst – TranscribeMe has opportunities. We are hiring for corporate staff in our San Francisco offices. Check out our Careers page for more details at www.transcribeme.com/careers. TranscribeMe is a fast growing start up with offices in New Zealand and San Francisco. Note: Transcribers can always apply at workhub.transcribeme.com.


text:
package org.scalatest.words

import org.scalatest.matchers._
import org.scalatest.enablers._
import java.lang.reflect.Method
import java.lang.reflect.Modifier
import scala.util.matching.Regex
import java.lang.reflect.Field
import scala.reflect.Manifest
import org.scalatest.MatchersHelper.transformOperatorChars
import scala.collection.Traversable
import org.scalatest.Assertions.areEqualComparingArraysStructurally
import scala.collection.GenTraversable
import scala.collection.GenSeq
import scala.collection.GenMap
import org.scalactic.Tolerance
import org.scalactic.Explicitly
import org.scalactic.EqualityPolicy.Spread
import org.scalactic.EqualityPolicy.TripleEqualsInvocation
import scala.annotation.tailrec
import org.scalactic.Equality
import org.scalatest.MatchersHelper.andMatchersAndApply
import org.scalatest.MatchersHelper.orMatchersAndApply
// SKIP-SCALATESTJS-START
import org.scalatest.MatchersHelper.matchSymbolToPredicateMethod
// SKIP-SCALATESTJS-END
import org.scalatest.{FailureMessages, UnquotedString}
import org.scalatest.MatchersHelper.newTestFailedException
import org.scalatest.MatchersHelper.fullyMatchRegexWithGroups
import org.scalatest.MatchersHelper.startWithRegexWithGroups
import org.scalatest.MatchersHelper.endWithRegexWithGroups
import org.scalatest.MatchersHelper.includeRegexWithGroups
import org.scalatest.exceptions.NotAllowedException
import org.scalatest.exceptions.StackDepthExceptionHelper.getStackDepthFun
import org.scalactic.Prettifier
import org.scalactic.Every
import org.scalactic.EqualityConstraint

/**
 * This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
 * the matchers DSL.
 *
 * @author Bill Venners
 */
sealed class ResultOfNotWordForAny[T](val left: T, val shouldBeTrue: Boolean) {

  /**
   * This method enables the following syntax:
   *
   *

   * result should not equal (7)
   *                   ^
   *

   */
  def equal[R](right: R)(implicit evidence: EqualityConstraint[T, R]) {
    if (evidence.areEqual(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotEqual(left, right)
        else
          FailureMessages.equaled(left, right)
      )
  }

  /**
   * This method enables the following syntax: // TODO: Write tests, including for special boolean error message
   *
   *

   * result should not be (7)
   *                   ^
   *

   */
  def be[R](right: R)(implicit evidence: EqualityConstraint[T, R]) {
    if (evidence.areEqual(left, right) != shouldBeTrue) {
      val rightIsBoolean = right.isInstanceOf[Boolean]
      val wasNotEqualTo = if (rightIsBoolean) "wasNot" else "wasNotEqualTo"
      val wasEqualTo = if (rightIsBoolean) "was" else "wasEqualTo"
      throw newTestFailedException(
        if (shouldBeTrue)
          if (rightIsBoolean)
            FailureMessages.wasNot(left, right)
          else
            FailureMessages.wasNotEqualTo(left, right)
        else
          if (rightIsBoolean)
            FailureMessages.was(left, right)
          else
            FailureMessages.wasEqualTo(left, right)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * result should not be_== (7)
   *                   ^
   *

   */
  def be_==(right: Any) {
    if ((left == right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotEqualTo(left, right)
        else
          FailureMessages.wasEqualTo(left, right)
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * map should not be_== (null)
   *                ^
   *

   */
  def be_==(o: Null)(implicit ev: T <:< AnyRef) {
    if ((left == null) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotNull(left)
        else
          FailureMessages.wasNull
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * result should not be <= (7)
   *                   ^
   *

   */
  def be(comparison: ResultOfLessThanOrEqualToComparison[T]) {
    if (comparison(left) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotLessThanOrEqualTo(left, comparison.right)
        else
          FailureMessages.wasLessThanOrEqualTo(left, comparison.right)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * result should not be >= (7)
   *                   ^
   *

   */
  def be(comparison: ResultOfGreaterThanOrEqualToComparison[T]) {
    if (comparison(left) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotGreaterThanOrEqualTo(left, comparison.right)
        else
          FailureMessages.wasGreaterThanOrEqualTo(left, comparison.right)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * result should not be < (7)
   *                   ^
   *

   */
  def be(comparison: ResultOfLessThanComparison[T]) {
    if (comparison(left) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotLessThan(left, comparison.right)
        else
          FailureMessages.wasLessThan(left, comparison.right)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * result should not be > (7)
   *                   ^
   *

   */
  def be(comparison: ResultOfGreaterThanComparison[T]) {
    if (comparison(left) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotGreaterThan(left, comparison.right)
        else
          FailureMessages.wasGreaterThan(left, comparison.right)
      )
    }
  }

  /**
   *
   * The deprecation period for the "be ===" syntax has expired, and the syntax
   * will now throw NotAllowedException.  Please use should equal, should ===, shouldEqual,
   * should be, or shouldBe instead.
   *
   *
   *

   * Note: usually syntax will be removed after its deprecation period. This was left in because otherwise the syntax could in some
   * cases still compile, but silently wouldn't work.
   *

   */
  @deprecated("The deprecation period for the be === syntax has expired. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.")
  def be(comparison: TripleEqualsInvocation[_]): Matcher[Any] = {
    throw new NotAllowedException(FailureMessages.beTripleEqualsNotAllowed,
                                  getStackDepthFun("ResultOfNotWordForAny.scala", "be"))
  }

  /**
   * This method enables the following syntax, where odd refers to
   * a BeMatcher[Int]:
   *
   *

   * 2 should not be (odd)
   *              ^
   *

   */
  def be(beMatcher: BeMatcher[T]) {
    val result = beMatcher(left)
    if (result.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          result.failureMessage
        else
          result.negatedFailureMessage
      )
    }
  }

  /**
   * This method enables the following syntax, where positiveNumber refers to
   * an AMatcher[Int]:
   *
   *

   * 2 should not be a (positiveNumber)
   *              ^
   *

   */
  def be(resultOfAWordToAMatcherApplication: ResultOfAWordToAMatcherApplication[T]) {
    val aMatcher = resultOfAWordToAMatcherApplication.aMatcher
    val result = aMatcher(left)
    if (result.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          result.failureMessage
        else
          result.negatedFailureMessage
      )
    }
  }

  /**
   * This method enables the following syntax, where oddNumber refers to
   * an AnMatcher[Int]:
   *
   *

   * 2 should not be an (oddNumber)
   *              ^
   *

   */
  def be(resultOfAnWordToAnMatcherApplication: ResultOfAnWordToAnMatcherApplication[T]) {
    val anMatcher = resultOfAnWordToAnMatcherApplication.anMatcher
    val result = anMatcher(left)
    if (result.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          result.failureMessage
        else
          result.negatedFailureMessage
      )
    }
  }

  import scala.language.experimental.macros

  /**
   * This method enables the following syntax:
   *
   *

   * result should not be a [Book]
   *                   ^
   *

   */
  def be(aType: ResultOfATypeInvocation[_]) = macro TypeMatcherMacro.checkATypeShouldBeTrueImpl

  /**
   * This method enables the following syntax:
   *
   *

   * result should not be a [Book]
   *                   ^
   *

   */
  def be(anType: ResultOfAnTypeInvocation[_]) = macro TypeMatcherMacro.checkAnTypeShouldBeTrueImpl

  /**
   * This method enables the following syntax:
   *
   *

   * sevenDotOh should not be (6.5 +- 0.2)
   *                       ^
   *

   */
  def be(spread: Spread[T]) {
    if (spread.isWithin(left) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotPlusOrMinus(left, spread.pivot, spread.tolerance)
        else
          FailureMessages.wasPlusOrMinus(left, spread.pivot, spread.tolerance)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * partialFun should not be definedAt ("apple")
   *                       ^
   *

   */
  def be[U](resultOfDefinedAt: ResultOfDefinedAt[U])(implicit ev: T <:< PartialFunction[U, _]) {
    if (left.isDefinedAt(resultOfDefinedAt.right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotDefinedAt(left, resultOfDefinedAt.right)
        else
          FailureMessages.wasDefinedAt(left, resultOfDefinedAt.right)
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * sevenDotOh should not equal (6.5 +- 0.2)
   *                       ^
   *

   */
  def equal(spread: Spread[T]) {
    if (spread.isWithin(left) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotEqualPlusOrMinus(left, spread.pivot, spread.tolerance)
        else
          FailureMessages.equaledPlusOrMinus(left, spread.pivot, spread.tolerance)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * result should not equal null
   *                   ^
   *

   */
  def equal(right: Null) {
    if ((left == null) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotEqualNull(left)
        else
          FailureMessages.equaledNull
      )
    }
  }

  /**
   * Enables parentheses to be placed around length (N) in expressions of the
   * form: should not have (length (N)).
   */
  def have(resultOfLengthWordApplication: ResultOfLengthWordApplication)(implicit len: Length[T]) {
    val right = resultOfLengthWordApplication.expectedLength
    val leftLength = len.lengthOf(left)
    if ((leftLength == right) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.hadLengthInsteadOfExpectedLength(left, leftLength, right)
        else
          FailureMessages.hadLength(left, right)
      )
    }
  }

  /**
   * Enables parentheses to be placed around size (N) in expressions of the
   * form: should not have (size (N)).
   */
  def have(resultOfSizeWordApplication: ResultOfSizeWordApplication)(implicit sz: Size[T]) {
    val right = resultOfSizeWordApplication.expectedSize
    val leftSize = sz.sizeOf(left)
    if ((leftSize == right) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.hadSizeInsteadOfExpectedSize(left, leftSize, right)
        else
          FailureMessages.hadSize(left, right)
      )
    }
  }

  // TODO: See about putting U <: T back in here, now that I got rid of the implicit conversion
  // that required me to get rid of the U and just use T. The idea is if I have a phoneBook should have (...)
  // that I could pass HavePropertyMatchers for any supertype of PhoneBook. I could use HavePropertyMatcher[Book]s
  // for example. So write a test and see if that doesn't work, and then if not, go ahead and put the U back.
  // Actually because the T is contravariant, a HavePropertyMatcher[Book] is already a subtype of HavePropertyMatcher[PhoneBook]
  // So I don't need the U <: T anyway. But maybe test to verify this would be worthwhile.
  // The type parameter U has T as its lower bound, which means that U must be T or a supertype of T. Left is T, oh, because
  // HavePropertyMatcher is contravariant in its type parameter T, and that nmakes sense, because a HavePropertyMatcher of Any should
  // be able to match on a String.
  // not have (a (1), b (2)) must mean the opposite of have (a (1), b (2)), which means that
  // not have (a (1), b (2)) will be true if either (a (1)).matches or (b (1)).matches is false.
  // Only if both (a (1)).matches or (b (1)).matches are true will not have (a (1), b (2)) be false.
  // title/author matches | have | have not
  // 0 0 | 0 | 1
  // 0 1 | 0 | 1
  // 1 0 | 0 | 1
  // 1 1 | 1 | 0
  //
  /**
   * This method enables the following syntax, where badBook is, for example, of type Book and
   * title ("One Hundred Years of Solitude") results in a HavePropertyMatcher[Book]:
   *
   *

   * book should not have (title ("One Hundred Years of Solitude"))
   *                 ^
   *

   */
  def have(firstPropertyMatcher: HavePropertyMatcher[T, _], propertyMatchers: HavePropertyMatcher[T, _]*) {

    val results =
      for (propertyVerifier <- firstPropertyMatcher :: propertyMatchers.toList) yield
        propertyVerifier(left)

    val firstFailureOption = results.find(pv => !pv.matches)

    val justOneProperty = propertyMatchers.length == 0

    // if shouldBeTrue is false, then it is like "not have ()", and should throw TFE if firstFailureOption.isDefined is false
    // if shouldBeTrue is true, then it is like "not (not have ()), which should behave like have ()", and should throw TFE if firstFailureOption.isDefined is true
    if (firstFailureOption.isDefined == shouldBeTrue) {
      firstFailureOption match {
        case Some(firstFailure) =>
          // This is one of these cases, thus will only get here if shouldBeTrue is true
          // 0 0 | 0 | 1
          // 0 1 | 0 | 1
          // 1 0 | 0 | 1
          throw newTestFailedException(
            FailureMessages.propertyDidNotHaveExpectedValue(
               UnquotedString(firstFailure.propertyName),
               firstFailure.expectedValue,
               firstFailure.actualValue,
               left
            )
          )
        case None =>
          // This is this cases, thus will only get here if shouldBeTrue is false
          // 1 1 | 1 | 0
          val failureMessage =
            if (justOneProperty) {
              val firstPropertyResult = results.head // know this will succeed, because firstPropertyMatcher was required
              FailureMessages.propertyHadExpectedValue(
                UnquotedString(firstPropertyResult.propertyName),
                firstPropertyResult.expectedValue,
                left
              )
            }
            else FailureMessages.allPropertiesHadExpectedValues(left)

          throw newTestFailedException(failureMessage)
      }
    }
  }

  def have(resultOfMessageWordApplication: ResultOfMessageWordApplication)(implicit messaging: Messaging[T]) {
    val right = resultOfMessageWordApplication.expectedMessage
    val actualMessage = messaging.messageOf(left)
    if ((actualMessage == right) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.hadMessageInsteadOfExpectedMessage(left, actualMessage, right)
        else
          FailureMessages.hadExpectedMessage(left, right)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * object should not contain ("one")
   *                   ^
   *

   */
  def contain[R](expectedElement: R)(implicit evidence: EvidenceThat[R]#CanBeContainedIn[T]) {
    val right = expectedElement
    if (evidence.contains(left, right) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainExpectedElement(left, right)
        else
          FailureMessages.containedExpectedElement(left, right)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * map should not be (null)
   *                ^
   *

   */
  def be(o: Null)(implicit ev: T <:< AnyRef) {
    if ((left == null) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotNull(left)
        else
          FailureMessages.wasNull
      )
    }
  }

  // SKIP-SCALATESTJS-START
  /**
   * This method enables the following syntax:
   *
   *

   * stack should not be ('empty)
   *                  ^
   *

   */
  def be(symbol: Symbol)(implicit toAnyRef: T <:< AnyRef) {
    val matcherResult = matchSymbolToPredicateMethod(toAnyRef(left), symbol, false, false)
    if (matcherResult.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue) matcherResult.failureMessage else matcherResult.negatedFailureMessage
      )
    }
  }
  // SKIP-SCALATESTJS-END

  /**
   * This method enables the following syntax, where stack is, for example, of type Stack and
   * empty refers to a BePropertyMatcher[Stack]:
   *
   *

   * stack should not be (empty)
   *                      ^
   *

   */
  def be(bePropertyMatcher: BePropertyMatcher[T])(implicit ev: T <:< AnyRef) {
    val result = bePropertyMatcher(left)
    if (result.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNot(left, UnquotedString(result.propertyName))
        else
          FailureMessages.was(left, UnquotedString(result.propertyName))
      )
    }
  }

  // SKIP-SCALATESTJS-START
  /**
   * This method enables the following syntax:
   *
   *

   * notFileMock should not be a ('file)
   *                        ^
   *

   */
  def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication)(implicit toAnyRef: T <:< AnyRef) {
    val matcherResult = matchSymbolToPredicateMethod(toAnyRef(left), resultOfAWordApplication.symbol, true, true)
    if (matcherResult.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue) matcherResult.failureMessage else matcherResult.negatedFailureMessage
      )
    }
  }
  // SKIP-SCALATESTJS-END

  /**
   * This method enables the following syntax, where notFileMock is, for example, of type File and
   * file refers to a BePropertyMatcher[File]:
   *
   *

   * notFileMock should not be a (file)
   *                        ^
   *

   */
  def be[U >: T](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: T <:< AnyRef) {
    val result = resultOfAWordApplication.bePropertyMatcher(left)
    if (result.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotA(left, UnquotedString(result.propertyName))
        else
          FailureMessages.wasA(left, UnquotedString(result.propertyName))
      )
    }
  }

  // SKIP-SCALATESTJS-START
  /**
   * This method enables the following syntax:
   *
   *

   * keyEvent should not be an ('actionKey)
   *                     ^
   *

   */
  def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit toAnyRef: T <:< AnyRef) {
    val matcherResult = matchSymbolToPredicateMethod(toAnyRef(left), resultOfAnWordApplication.symbol, true, false)
    if (matcherResult.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue) matcherResult.failureMessage else matcherResult.negatedFailureMessage
      )
    }
  }
  // SKIP-SCALATESTJS-END

  /**
   * This method enables the following syntax, where keyEvent is, for example, of type KeyEvent and
   * actionKey refers to a BePropertyMatcher[KeyEvent]:
   *
   *

   * keyEvent should not be an (actionKey)
   *                     ^
   *

   */
  def be[U >: T](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: T <:< AnyRef) {
    val result = resultOfAnWordApplication.bePropertyMatcher(left)
    if (result.matches != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotAn(left, UnquotedString(result.propertyName))
        else
          FailureMessages.wasAn(left, UnquotedString(result.propertyName))
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * otherString should not be theSameInstanceAs (string)
   *                        ^
   *

   */
  def be(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: T <:< AnyRef) {
    if ((resultOfSameInstanceAsApplication.right eq toAnyRef(left)) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotSameInstanceAs(left, resultOfSameInstanceAsApplication.right)
        else
          FailureMessages.wasSameInstanceAs(left, resultOfSameInstanceAsApplication.right)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * xs should not be sorted
   *                  ^
   *

   */
  def be[U](sortedWord: SortedWord)(implicit sortable: Sortable[T]) {
    if (sortable.isSorted(left) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotSorted(left)
        else
          FailureMessages.wasSorted(left)
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * file should not be readable
   *                    ^
   *

   */
  def be[U](readableWord: ReadableWord)(implicit readability: Readability[T]) {
    if (readability.isReadable(left) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotReadable(left)
        else
          FailureMessages.wasReadable(left)
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * file should not be writable
   *                    ^
   *

   */
  def be[U](writableWord: WritableWord)(implicit writability: Writability[T]) {
    if (writability.isWritable(left) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotWritable(left)
        else
          FailureMessages.wasWritable(left)
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * list should not be empty
   *                    ^
   *

   */
  def be[U](emptyWord: EmptyWord)(implicit emptiness: Emptiness[T]) {
    if (emptiness.isEmpty(left) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotEmpty(left)
        else
          FailureMessages.wasEmpty(left)
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * option should not be defined
   *                      ^
   *

   */
  def be[U](definedWord: DefinedWord)(implicit definition: Definition[T]) {
    if (definition.isDefined(left) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.wasNotDefined(left)
        else
          FailureMessages.wasDefined(left)
      )
  }

  def contain[R](newOneOf: ResultOfOneOfApplication[R])(implicit evidence: EvidenceThat[R]#CanBeContainedIn[T]) {

    val right = newOneOf.right

    if (evidence.containsOneOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainOneOfElements(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
        else
          FailureMessages.containedOneOfElements(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
      )
  }

  def contain[R](oneElementOf: ResultOfOneElementOfApplication[R])(implicit evidence: EvidenceThat[R]#CanBeContainedIn[T]) {

    val right = oneElementOf.right

    if (evidence.containsOneOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainOneElementOf(left, right)
        else
          FailureMessages.containedOneElementOf(left, right)
      )
  }

  def contain[R](atLeastOneOf: ResultOfAtLeastOneOfApplication[R])(implicit aggregating: EvidenceThat[R]#CanBeContainedInAggregation[T]) {

    val right = atLeastOneOf.right

    if (aggregating.containsAtLeastOneOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainAtLeastOneOf(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
        else
          FailureMessages.containedAtLeastOneOf(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
      )
  }

  def contain[R](atLeastOneElementOf: ResultOfAtLeastOneElementOfApplication[R])(implicit aggregating: EvidenceThat[R]#CanBeContainedInAggregation[T]) {

    val right = atLeastOneElementOf.right

    if (aggregating.containsAtLeastOneOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainAtLeastOneElementOf(left, right)
        else
          FailureMessages.containedAtLeastOneElementOf(left, right)
      )
  }

  def contain[R](noneOf: ResultOfNoneOfApplication[R])(implicit containing: EvidenceThat[R]#CanBeContainedIn[T]) {

    val right = noneOf.right

    if (containing.containsNoneOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.containedAtLeastOneOf(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
        else
          FailureMessages.didNotContainAtLeastOneOf(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
      )
  }

  def contain[R](noElementsOf: ResultOfNoElementsOfApplication[R])(implicit containing: EvidenceThat[R]#CanBeContainedIn[T]) {

    val right = noElementsOf.right

    if (containing.containsNoneOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.containedAtLeastOneOf(left, right)
        else
          FailureMessages.didNotContainAtLeastOneOf(left, right)
      )
  }

  def contain[R](theSameElementsAs: ResultOfTheSameElementsAsApplication[R])(implicit aggregating: EvidenceThat[R]#CanBeContainedInAggregation[T]) {

    val right = theSameElementsAs.right

    if (aggregating.containsTheSameElementsAs(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainSameElements(left, right)
        else
          FailureMessages.containedSameElements(left, right)
      )
  }

  def contain[R](theSameElementsInOrderAs: ResultOfTheSameElementsInOrderAsApplication[R])(implicit sequencing: EvidenceThat[R]#CanBeContainedInSequence[T]) {

    val right = theSameElementsInOrderAs.right

    if (sequencing.containsTheSameElementsInOrderAs(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainSameElementsInOrder(left, right)
        else
          FailureMessages.containedSameElementsInOrder(left, right)
      )
  }

  def contain[R](only: ResultOfOnlyApplication[R])(implicit aggregating: EvidenceThat[R]#CanBeContainedInAggregation[T]) {

    val right = only.right
    if (aggregating.containsOnly(left, right) != shouldBeTrue) {
      val withFriendlyReminder = right.size == 1 && (right(0).isInstanceOf[scala.collection.GenTraversable[_]] || right(0).isInstanceOf[Every[_]])
      throw newTestFailedException(
        if (shouldBeTrue)
          if (withFriendlyReminder)
            FailureMessages.didNotContainOnlyElementsWithFriendlyReminder(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
          else
            FailureMessages.didNotContainOnlyElements(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
        else
          if (withFriendlyReminder)
            FailureMessages.containedOnlyElementsWithFriendlyReminder(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
          else
            FailureMessages.containedOnlyElements(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
      )
    }
  }

  def contain[R](only: ResultOfInOrderOnlyApplication[R])(implicit sequencing: EvidenceThat[R]#CanBeContainedInSequence[T]) {
    val right = only.right
    if (sequencing.containsInOrderOnly(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainInOrderOnlyElements(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
        else
          FailureMessages.containedInOrderOnlyElements(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
      )
  }

  def contain[R](only: ResultOfAllOfApplication[R])(implicit aggregating: EvidenceThat[R]#CanBeContainedInAggregation[T]) {

    val right = only.right
    if (aggregating.containsAllOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainAllOfElements(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
        else
          FailureMessages.containedAllOfElements(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
      )
  }

  def contain[R](only: ResultOfAllElementsOfApplication[R])(implicit aggregating: EvidenceThat[R]#CanBeContainedInAggregation[T]) {

    val right = only.right
    if (aggregating.containsAllOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainAllElementsOf(left, right)
        else
          FailureMessages.containedAllElementsOf(left, right)
      )
  }

  def contain[R](only: ResultOfInOrderApplication[R])(implicit sequencing: EvidenceThat[R]#CanBeContainedInSequence[T]) {

    val right = only.right
    if (sequencing.containsInOrder(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainAllOfElementsInOrder(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
        else
          FailureMessages.containedAllOfElementsInOrder(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
      )
  }

  def contain[R](only: ResultOfInOrderElementsOfApplication[R])(implicit sequencing: EvidenceThat[R]#CanBeContainedInSequence[T]) {

    val right = only.right
    if (sequencing.containsInOrder(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainAllElementsOfInOrder(left, right)
        else
          FailureMessages.containedAllElementsOfInOrder(left, right)
      )
  }

  def contain[R](atMostOneOf: ResultOfAtMostOneOfApplication[R])(implicit aggregating: EvidenceThat[R]#CanBeContainedInAggregation[T]) {

    val right = atMostOneOf.right

    if (aggregating.containsAtMostOneOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainAtMostOneOf(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
        else
          FailureMessages.containedAtMostOneOf(left, UnquotedString(right.map(FailureMessages.decorateToStringValue).mkString(", ")))
      )
  }

  def contain[R](atMostOneElementOf: ResultOfAtMostOneElementOfApplication[R])(implicit aggregating: EvidenceThat[R]#CanBeContainedInAggregation[T]) {

    val right = atMostOneElementOf.right

    if (aggregating.containsAtMostOneOf(left, right) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainAtMostOneElementOf(left, right)
        else
          FailureMessages.containedAtMostOneElementOf(left, right)
      )
  }

  def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication)(implicit keyMapping: KeyMapping[T]) {
    val right: Any = resultOfKeyWordApplication.expectedKey
    if (keyMapping.containsKey(left, right) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainKey(left, right)
        else
          FailureMessages.containedKey(left, right)
      )
    }
  }
  def contain(resultOfValueWordApplication: ResultOfValueWordApplication)(implicit valueMapping: ValueMapping[T]) {
    val right: Any = resultOfValueWordApplication.expectedValue
    if (valueMapping.containsValue(left, right) != shouldBeTrue) {
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotContainValue(left, right)
        else
          FailureMessages.containedValue(left, right)
      )
    }
  }

  /**
   * This method enables the following syntax:
   *
   *

   * string should not fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
   *                   ^
   *

   *
   *

   * The regular expression passed following the regex token can be either a String
   * or a scala.util.matching.Regex.
   *

   */
  def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: T <:< String) {
    val result = fullyMatchRegexWithGroups(left, resultOfRegexWordApplication.regex, resultOfRegexWordApplication.groups)
    if (result.matches != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue) result.failureMessage else result.negatedFailureMessage
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * string should not include regex ("wo.ld")
   *                   ^
   *

   *
   *

   * The regular expression passed following the regex token can be either a String
   * or a scala.util.matching.Regex.
   *

   */
  def include(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: T <:< String) {
    val result = includeRegexWithGroups(left, resultOfRegexWordApplication.regex, resultOfRegexWordApplication.groups)
    if (result.matches != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue) result.failureMessage else result.negatedFailureMessage
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * string should not include ("world")
   *                   ^
   *

   */
  def include(expectedSubstring: String)(implicit ev: T <:< String) {
    if ((left.indexOf(expectedSubstring) >= 0) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotIncludeSubstring(left, expectedSubstring)
        else
          FailureMessages.includedSubstring(left, expectedSubstring)
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * string should not startWith regex ("Hel*o")
   *                   ^
   *

   *
   *

   * The regular expression passed following the regex token can be either a String
   * or a scala.util.matching.Regex.
   *

   */
  def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: T <:< String) {
    val result = startWithRegexWithGroups(left, resultOfRegexWordApplication.regex, resultOfRegexWordApplication.groups)
    if (result.matches != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue) result.failureMessage else result.negatedFailureMessage
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * "eight" should not startWith ("1.7")
   *                    ^
   *

   */
  def startWith(expectedSubstring: String)(implicit ev: T <:< String) {
    if ((left.indexOf(expectedSubstring) == 0) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotStartWith(left, expectedSubstring)
        else
          FailureMessages.startedWith(left, expectedSubstring)
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * greeting should not endWith regex ("wor.d")
   *                     ^
   *

   */
  def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: T <:< String) {
    val result = endWithRegexWithGroups(left, resultOfRegexWordApplication.regex, resultOfRegexWordApplication.groups)
    if (result.matches != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue) result.failureMessage else result.negatedFailureMessage
      )
  }

  /**
   * This method enables the following syntax:
   *
   *

   * "eight" should not endWith ("1.7")
   *                    ^
   *

   */
  def endWith(expectedSubstring: String)(implicit ev: T <:< String) {
    if ((left endsWith expectedSubstring) != shouldBeTrue)
      throw newTestFailedException(
        if (shouldBeTrue)
          FailureMessages.didNotEndWith(left, expectedSubstring)
        else
          FailureMessages.endedWith(left, expectedSubstring)
      )
  }

  import scala.language.experimental.macros

  /**
   * This method enables the following syntax:
   *
   *

   * result should not matchPattern { case Person("Bob", _) => }
   *                   ^
   *

   */
  def matchPattern(right: PartialFunction[Any, _]) = macro MatchPatternMacro.matchPattern

  /**
   * Overrides toString to return pretty text.
   */
  override def toString: String = "ResultOfNotWordForAny(" + Prettifier.default(left) + ", " + Prettifier.default(shouldBeTrue) + ")"
}

redpajama_set_name: RedPajamaGithub


text:
8/5/2005 — By Carol Sottili
Slowing down comes second nature in the Old World--and there's no better way to take it easy than on a nice, calm river cruise
What's the experience like?
Because the boats rarely carry more than 200 people--10 times fewer passengers than the average ocean liner--river cruises are decidedly more intimate. They're also less frenzied; the main activities are relaxing on deck and low-impact sightseeing. "It's neat to sit and watch people fishing, kids playing, and other boats going by," says Shirley Linde, author of The World's Most Intimate Cruises. Some of the newer riverboats do have gyms or pools, but most are without the bells and whistles of ocean cruisers. Entertainment, such as it is, comes in the form of a piano bar, cultural lectures, or the crew doing cute song-and-dance routines from their homelands. You'll be fed well, but not constantly (no 24-hour buffets). Typically there's a single restaurant serving a buffet breakfast and lunch, and a multicourse dinner with a choice of entrées. Dress is almost always casual.
Can a river cruise sub for a traditional tour?
Whereas big-ship cruises in Europe often stop far from the actual destination--the port of Civitavecchia, for example, is an hour from Rome--the major plus of a riverboat is that it pulls right into the middle of preserved medieval towns such as Bamberg, Germany. The downside is that these aren't big-ticket destinations. If you have your mind set on seeing the Parthenon or Big Ben, then no, a river cruise doesn't work. River cruises explore smaller towns and villages, and give a terrific feel for the Old World. Like traditional guided tours, river cruises sometimes offer special-interest itineraries that focus on wine, gardens, or classical music. But on a boat you don't have to switch hotels every few days. "It's a great way to experience different cultures," says Eike Grabowski, a travel agent from Shallotte, N.C. "I'm not crazy about getting up at 6 a.m. and putting my luggage outside the door."
Where are cruises offered?
Popular options are the Danube, often combined with the Main and featuring visits to castles and gothic cathedrals in Hungary, Austria, and Germany; the Elbe, which meanders through Germany and the Czech Republic and stops at Dresden, completely rebuilt from the notorious bombing in World War II; France's Rhône and Saône, taking clients through the scenic regions of Provence and Burgundy; the Seine, for Paris as well as Claude Monet's hometown of Giverny; the Po in northern Italy, frequently themed around opera; and Russia's Volga River, connecting Moscow and St. Petersburg. A more unusual choice is Portugal's Douro River, where vineyards and wild, undeveloped landscapes are the backdrop.
What about barges?
Barges are smaller (6 to 50 passengers), slower (max of around 5 mph vs. 12 mph on a river cruise), and are usually seen on narrow waterways, notably in France. Private groups often rent an entire barge, and because the vessels are so easy to navigate, self-drives are possible. Brokers such as The Barge Connection book self-drives starting at around $2,000 a week for a six-berth barge, as well as crewed voyages that, depending on cabin sizes, amenities, menu, and staff, cost $1,600 to $5,000 per person per week.
Who's onboard?
For journeys lasting 10 days or longer, the average passenger is educated, well-traveled, and over 60. Weeklong cruises attract more folks in their 40s and 50s, as well as occasional young couples. Families with children are uncommon, and some lines don't even allow anyone under 12 onboard.
Will everyone speak English?
Crews on all ships will speak some English, and the staff on lines such as Viking River Cruises, Uniworld, and Avalon Waterways, all of which cater to the North American market, will be fluent. Operators based on the Continent, such as CroisiEurope, attract mostly European passengers, so you may not be able to communicate with everyone.
What are cabins like?
Standard cabins on ships built in the 1980s can be as small as 90 square feet, while the average room on many new boats is 200 square feet. Nearly all lines offer only outside cabins, so you can expect a window and a view. The cheapest rooms are just above water level, where the scenery isn't as good. Riverboats are narrow, so they rarely have room to provide balconies. It's standard for cabins to come with a hair dryer, air-conditioning, and TV.
When should I go?
The peak seasons are late spring and early fall, when temperatures are neither too hot nor too cold. You'll find the cheapest prices during the iffy periods of early spring and late autumn, and some lines have discounts during the hottest weeks of July and August. (The savings might be negated because that's when airfare costs the most.) Many passengers plan their cruises according to the agricultural cycle. "If you're interested in wine, you may want to go when the grapes are being harvested in the fall," says author Linde. "And if you want to see tulips in Holland, go in April."
It depends on the cruise line and the season. Avalon, a middle-of-the-pack line, has a seven-night "Tulip Time" cruise through Holland and Belgium starting at $1,600 per person. Viking, which offers a similar level of luxury, lists promotions on its website, sometimes bringing rates down to less than $1,000 for a week. Grand Circle Travel, a general tour operator that markets to Americans 50 and older, offers nine different river cruises in Europe, sometimes for as little as $1,000 with airfare from New York. The international clientele of Sea Cloud Cruises are used to paying over $3,000 a week for outstanding food, sophisticated atmosphere, and huge cabins with marble floors in the bathrooms.
What costs extra?
The cruise price covers three meals per day, and oftentimes afternoon tea, wine at dinner, and guided excursions. Tips are not included. There'll be an envelope in your cabin for gratuities; the standard is for each passenger to leave around $10 per day--preferably in the local currency.
The Barge Connection 888/550-8580, bargeconnection.com
Viking River Cruises 877/668-4546, vikingrivercruises.com
Uniworld 800/360-9550, uniworld.com
Avalon Waterways 877/797-8791, avalonwaterways.com
CroisiEurope 888/863-1212, croisieurope.com
Grand Circle Travel 800/248-3737, gct.com
Sea Cloud Cruises 888/732-2568, seacloud.com
Peter Deilmann Cruises 800/348-8287, deilmann-cruises.com
6 Family-Friendly All-Inclusive Resorts We Love
Harry Potter Fans: Here's Where You Should Travel ...
Gettysburg National Military Park: How to Visit Wi...
Disneyland's Sleeping Beauty's Castle Gets a Makeo...


text:
Q: Get the value of table data from the same row I'm trying to explain my question the best I can, so sorry if it's a bit confusing.
I have in my HTML Table, with table row, and table data, each row is filled with data from data base, and the table is automatically generated.
Example is below.

                    Place ID
                    Map Name
                    Place Name
                    Price 1
                    Price 2
                    Price 3
                    Price 4
                    @if (Auth::user()->role == "admin")
                      Action
                      Booking
                    @endif

              @foreach ($places as $place)

                    {{ $place->place_id }}
                    {{ $place->map_name }}
                    {{ $place->place_name }}
                    {{ $place->price1 }} €
                    {{ $place->price2 }} €
                    {{ $place->price3 }} €
                    {{ $place->price4 }} €

For booking table head, its filled with a quick booking button, that is supposed to get the Place ID of the data from the same raw, and shows it inside a popup, bellow is the code that creates the popup and fills the data.
{{-- status print --}}

                      @if ($place->status==0)

                      Quick Book

                          <form method=POST action="{{ route('admin.place.quickbooking') }}">

                              <button type="button" class="close" data-dismiss="modal">×</button>

Quick Book

                              @csrf

                                ID:
                                <input type="text" class="form-control" value="{{ $place->place_id }}" id="qBookingID" name="qID" readonly>
                                Full Name:
                                <input type="text" class="form-control" value="{{ Auth::user()->name }}" id="qBookingFullName" name="qFullName">
                                Number of Guests:
                                <input type="number" class="form-control" id="qBookingNumberOfGuests" name="qNumberOfGuests">
                                Number of Babies:
                                <input type="number" class="form-control" id="qBookingNumberOfBabies" name="qNumberOfBabies">
                                Check In:
                                <input type="text" class="form-control" value="{{ session()->get('startingRange') }}" id="qBookingStartDate" name="qStartDate" readonly>
                                Check Out:
                                <input type="text" class="form-control" value="{{ session()->get('endingRange') }}" id="qBookingEndDate" name="qEndDate" readonly>

                                Map Name: {{  $place->map_name }}

                                Booked By: {{  Auth::user()->name }}

                              {{-- place_id,) }}">Book --}}

                              <button type="button" class="btn btn-default" data-dismiss="modal" style="color: red; border: 1px solid red;" >Close</button>
                              <button type="submit" class="btn btn-default" style="color: green; border: 1px solid green;" type="submit">Book</button>

                        </form>

                      @endif

                      @if ($place->status==-1)

Disabled

                      @endif
                      @if ($place->status==2)

Busy

                      @endif

My problem is that the auto filled ID is only being filled by the First Data, as no matter which row I click on, the ID stays the same "the first ID from the table"
Any idea what might be causing this, or am I missing something very obvious?
THank you for your help.

A: For your case the better choice is pass the object place to a function using javascript, every time that you give click the modal appears with the data
that you want to edit or show.
id }}">Edit
    @push('script')

@endpush

redpajama_set_name: RedPajamaStackExchange


Personification undertakes dreamlike journeys through crumbling architecture and airless interiors, discovering anachronistic and apocalyptic emblems among the commonplace particulars of modern day life. Breaking open in order to reinhabit the language of Puritan allegory and captivity narrative, these poems meditate on the possibility of personhood generated by the constraints of luminous unknowing, a form of captivity in which one is both bound and held rapt. They proceed by way of detour, boredom's indirection, and astonished pauses, endlessly seeking "the perfect thought / we slept frozen inside / yet could not see." Of Personification, Carl Phillips writes, "Here is a strange and arresting vision, indeed."
MARGARET RONDA received an MFA from Indiana University and a Ph.D. in English from the University of California - Berkeley. She is currently the Holloway Postdoctoral Fellow in Poetry at Berkeley. Her poems have appeared in journals such as Gulf Coast, AGNI, Fourteen Hills, POOL, Prairie Schooner, and Aufgabe. She divides her time between California and Oregon.


Same as a KTM 530 w/ a 1mm bigger wrist pin.
have you the exact size please?
Big End Diam. : ??
Small End Diam : ??
Bid End Depth : ??
Sorry no I don't, have you called carillo or sent them an email to ask? I know they have made a few rods for friends so they may have the data.
As long as they have every thing but the wrist pin end for the KTM 530EXC they have everything but the wrist pin measure - I will measure the wrist pin end on the 570 crank I have and post it for you in a little while. Crank is still together or I would measure the big end also. He need to talk to someone about the KTM info as it is the same.


text:
Prince Harry, Meghan Markle's wedding to be presented in theaters
Wade Sheridan
Prince Harry (R) and Meghan Markle. The royal wedding will be presented in theaters through Fathom Events. File Photo by Andy Rain/EPA-EFE
Prince Harry (L) and Meghan Markle. The royal wedding will be presented in theaters through Fathom Events. File Photo by Nigel Roddis/EPA-EFE
May 17 (UPI) -- Fathom Events is bringing the royal wedding between Prince Harry and Meghan Markle to theaters across the United States on Saturday.
Fathom will be releasing an exclusive theatrical presentation of the big day using encore footage from ITV's royal wedding coverage commercial free.
The special one-day theater event titled "The Big Day on the Big Screen," hails from Fathom Events and BritBox, a streaming collection of British television in the U.S. created by the BBC and ITV.
The wedding will be presented in theaters starting at 10 a.m. ET. The ceremony is set to take place at St. George's Chapel at Windsor Castle in England starting at noon GMT, 7 a.m. ET.
This marks the first time ever that a royal wedding will be featured in select cinemas.
Markle and Harry selected their bridesmaids and page boys on Wednesday for the ceremony which includes Harry's nephew and niece, Prince George, 4, and Princess Charlotte, 2, the children of Prince William and Kate Middleton.
Meghan Markle confirms father will not attend royal wedding Royal wedding party includes Prince George, Princess Charlotte What we know about Prince Harry, Meghan Markle's wedding